Merge remote-tracking branch 'upstream/master'

merging from upstream

.idea/dataSources.xml

@@ -21,8 +21,8 @@
       <driver-ref>mysql</driver-ref>
       <jdbc-driver>com.mysql.jdbc.Driver</jdbc-driver>
       <jdbc-url>jdbc:mysql://127.0.0.1:3306/alliance_mumble</jdbc-url>
-      <user-name>allianceauth</user-name>
+      <user-name>alliancemumble</user-name>
-      <user-password>dfcbdfc6dfc6dfc3dfcbdfc4dfc9dfcfdfcbdfdfdfdedfc2</user-password>
+      <user-password>dfcbdfc6dfc6dfc3dfcbdfc4dfc9dfcfdfc7dfdfdfc7dfc8dfc6dfcf</user-password>
       <libraries />
     </data-source>
   </component>

README.md

@@ -3,7 +3,7 @@ allianceauth
 Alliance service auth to help large scale alliances manage services.
 Built for "The 99 Percent" open for anyone to use
 
-Requirments:
+Requirements:
 
     # Django Stuff #
     django 1.6.1
@@ -21,7 +21,7 @@ Requirments:
     python-dnspython
     
     # Needed Apps
-    rabbitmq
+    celeryd
     bcrypt
     
 Services Interaction:
@@ -34,24 +34,18 @@ Services Interaction:
     
 Startup Instructions:
 
-    python syncdb
+    ./bootstrap.sh (Sudo if needed)
-    python manage.py celeryd --verbosity=2 --loglevel=DEBUG
+    ./startup.sh
-    python manage.py celerybeat --verbosity=2 --loglevel=DEBUG
+    ./shutdown.sh
-    python manage.py runserver
+    
 
 Special Permissions In Admin:
+
     auth | user | alliance_member ( Added auto by auth when a member is verified )
     auth | user | group_management ( Access to add members to groups within the alliance )
     auth | user | human_resources ( Corp only access to view applications )
     auth | user | jabber_broadcast ( Access to broadcast a message over jabber to specific groups or all)
-
+    auth | user | blue_memeber ( Auto Added to people who register has a blue when adding api key)
-
-Note:
-
-    In order to create permissions automatically you there is a "bootstrap_permissions" function in the
-    __init__.py of the groupmanagement folder. Comment out before running syncdb, after add it back.
-    This is there because i currently have no idea how to do this any other way.
-
     
 
-Eve alliance auth for the 99 percent
+Brought to you by The 99 Percent skunkworks.

alliance_auth/settings.py

@@ -13,11 +13,9 @@ import os
 
 import djcelery
 
-
 djcelery.setup_loader()
 BASE_DIR = os.path.dirname(os.path.dirname(__file__))
 
-
 # Quick-start development settings - unsuitable for production
 # See https://docs.djangoproject.com/en/1.6/howto/deployment/checklist/
 
@@ -103,8 +101,8 @@ DATABASES = {
     'mumble': {
         'ENGINE': 'django.db.backends.mysql',
         'NAME': 'alliance_mumble',
-        'USER': 'allianceauth',
+        'USER': 'alliancemumble',
-        'PASSWORD': 'allianceauth',
+        'PASSWORD': 'alliancemumble',
         'HOST': '127.0.0.1',
         'PORT': '3306',
     }
@@ -148,22 +146,26 @@ USE_L10N = True
 
 USE_TZ = True
 
-
 # Static files (CSS, JavaScript, Images)
 # https://docs.djangoproject.com/en/1.6/howto/static-files/
-
 STATIC_URL = '/static/'
 
 DEFAULT_ALLIANCE_GROUP = 'AllianceMember'
+DEFAULT_BLUE_GROUP = 'BlueMember'
 
 # ALLIANCE INFO
 ALLIANCE_ID = '99001336'
 ALLIANCE_NAME = 'Somealliance'
 
+# Needed to update standings
+ALLIANCE_EXEC_CORP_ID = ''
+ALLIANCE_EXEC_CORP_VCODE = ''
+ALLIANCE_BLUE_STANDING = 5.0
+
 # Forum URL
 FORUM_URL = "http://someaddress.com"
 
-# Jabber Prosody Info
+# Jabber information
 JABBER_URL = "someaddress.com"
 JABBER_PORT = 5223
 JABBER_SERVER = "someadddress.com"

alliance_auth/urls.py

@@ -92,8 +92,12 @@ urlpatterns = patterns('',
                            name='auth_reset_jabber_password'),
 
                        # Mumble service contraol
+                       url(r'^activate_blue_mumble/$', 'services.views.activate_blue_mumble',
+                           name='auth_activate_blue_mumble'),
                        url(r'^activate_mumble/$', 'services.views.activate_mumble', name='auth_activate_mumble'),
                        url(r'^deactivate_mumble/$', 'services.views.deactivate_mumble', name='auth_deactivate_mumble'),
+                       url(r'^deactivate_blue_mumble/$', 'services.views.deactivate_blue_mumble',
+                           name='auth_deactivate_blue_mumble'),
                        url(r'^reset_mumble_password/$', 'services.views.reset_mumble_password',
                            name='auth_reset_mumble_password'),
 

authentication/managers.py

@@ -56,3 +56,11 @@ class AuthServicesInfoManager:
             authserviceinfo.mumble_username = username
             authserviceinfo.mumble_password = password
             authserviceinfo.save(update_fields=['mumble_username', 'mumble_password'])
+
+    @staticmethod
+    def update_is_blue(is_blue, user):
+        if User.objects.filter(username=user.username).exists():
+            authserviceinfo = AuthServicesInfoManager.__get_or_create(user)
+            authserviceinfo.is_blue = is_blue
+            authserviceinfo.save(update_fields=['is_blue'])
+

authentication/models.py

@@ -10,7 +10,7 @@ class AuthServicesInfo(models.Model):
     mumble_username = models.CharField(max_length=254, default="")
     mumble_password = models.CharField(max_length=254, default="")
     main_char_id = models.CharField(max_length=64, default="")
-
+    is_blue = models.BooleanField(default=False)
     user = models.ForeignKey(User)
 
     def __str__(self):

celerytask/tasks.py

@@ -66,9 +66,6 @@ def add_to_databases(user, groups, syncgroups):
         for group in groups:
             syncgroup = syncgroups.filter(groupname=group.name)
             if not syncgroup:
-                # gotta create group
-                # create syncgroup
-                # create service groups
                 synccache = SyncGroupCache()
                 synccache.groupname = group.name
                 synccache.user = user
@@ -155,7 +152,8 @@ def run_api_refresh():
                             if main_alliance_id == settings.ALLIANCE_ID:
                                 pass
                             else:
-                                deactivate_services(user)
+                                if not authserviceinfo.is_blue:
+                                    deactivate_services(user)
                         else:
                             # nuke it
                             deactivate_services(user)
@@ -166,17 +164,16 @@ def run_api_refresh():
 # Run Every 2 hours
 @periodic_task(run_every=crontab(minute=0, hour="*/2"))
 def run_alliance_corp_update():
+    # I am not proud of this block of code
     if EveApiManager.check_if_api_server_online():
 
         # Updated alliance info
         alliance_info = EveApiManager.get_alliance_information(settings.ALLIANCE_ID)
+
         # Populate alliance info
         if not EveManager.check_if_alliance_exists_by_id(settings.ALLIANCE_ID):
             EveManager.create_alliance_info(settings.ALLIANCE_ID, alliance_info['name'], alliance_info['ticker'],
-                                            alliance_info['executor_id'], alliance_info['member_count'])
+                                            alliance_info['executor_id'], alliance_info['member_count'], False)
-
-        EveManager.update_alliance_info(settings.ALLIANCE_ID, alliance_info['executor_id'],
-                                        alliance_info['member_count'])
 
         alliance = EveManager.get_alliance_info_by_id(settings.ALLIANCE_ID)
 
@@ -185,13 +182,101 @@ def run_alliance_corp_update():
             corpinfo = EveApiManager.get_corporation_information(alliance_corp)
             if not EveManager.check_if_corporation_exists_by_id(corpinfo['id']):
                 EveManager.create_corporation_info(corpinfo['id'], corpinfo['name'], corpinfo['ticker'],
-                                                   corpinfo['members']['current'], alliance)
+                                                   corpinfo['members']['current'], False, alliance)
 
-        # Update all the corps
+        # Create the corps in the standings
-        for all_corp_info in EveManager.get_all_corporation_info():
+        alliance_standings = EveApiManager.get_alliance_standings()
-            corpinfo = EveApiManager.get_corporation_information(all_corp_info.corporation_id)
+        if alliance_standings:
-            if corpinfo['alliance']['id'] == int(settings.ALLIANCE_ID):
+            for standing_id in EveApiManager.get_alliance_standings()['alliance']:
-                EveManager.update_corporation_info(corpinfo['id'], corpinfo['members']['current'], alliance)
+                if int(alliance_standings['alliance'][standing_id]['standing']) >= settings.ALLIANCE_BLUE_STANDING:
+                    if EveApiManager.check_if_id_is_character(standing_id):
+                        pass
+                    elif EveApiManager.check_if_id_is_corp(standing_id):
+                        corpinfo = EveApiManager.get_corporation_information(standing_id)
+                        if not EveManager.check_if_corporation_exists_by_id(standing_id):
+                            EveManager.create_corporation_info(corpinfo['id'], corpinfo['name'], corpinfo['ticker'],
+                                                               corpinfo['members']['current'], True, None)
+                    else:
+                        # Alliance id create corps
+                        blue_alliance_info = EveApiManager.get_alliance_information(standing_id)
+
+                        if not EveManager.check_if_alliance_exists_by_id(standing_id):
+                            EveManager.create_alliance_info(standing_id, blue_alliance_info['name'],
+                                                            blue_alliance_info['ticker'],
+                                                            blue_alliance_info['executor_id'],
+                                                            blue_alliance_info['member_count'], True)
+
+                        blue_alliance = EveManager.get_alliance_info_by_id(standing_id)
+
+                        for blue_alliance_corp in blue_alliance_info['member_corps']:
+                            blue_info = EveApiManager.get_corporation_information(blue_alliance_corp)
+                            if not EveManager.check_if_corporation_exists_by_id(blue_info['id']):
+                                EveManager.create_corporation_info(blue_info['id'], blue_info['name'],
+                                                                   blue_info['ticker'],
+                                                                   blue_info['members']['current'], True, blue_alliance)
+
+        # Update all allinace info's
+        for all_alliance_info in EveManager.get_all_alliance_info():
+            all_alliance_api_info = EveApiManager.get_alliance_information(all_alliance_info.alliance_id)
+            if all_alliance_info.alliance_id == settings.ALLIANCE_ID:
+                EveManager.update_alliance_info(all_alliance_api_info['id'], all_alliance_api_info['executor_id'],
+                                                all_alliance_api_info['member_count'], False)
             else:
-                # No longer in the alliance nuke it
+                if int(alliance_standings['alliance'][int(all_alliance_info.alliance_id)][
-                all_corp_info.delete()
+                    'standing']) >= settings.ALLIANCE_BLUE_STANDING:
+                    EveManager.update_alliance_info(all_alliance_api_info['id'], all_alliance_api_info['executor_id'],
+                                                    all_alliance_api_info['member_count'], True)
+                else:
+                    EveManager.update_alliance_info(all_alliance_api_info['id'], all_alliance_api_info['executor_id'],
+                                                    all_alliance_api_info['member_count'], False)
+
+        # Update corp infos
+        for all_corp_info in EveManager.get_all_corporation_info():
+            alliance = None
+            corpinfo = EveApiManager.get_corporation_information(all_corp_info.corporation_id)
+            if corpinfo['alliance']['id'] is not None:
+                alliance = EveManager.get_alliance_info_by_id(corpinfo['alliance']['id'])
+
+            if alliance is not None:
+                if all_corp_info.alliance.alliance_id == settings.ALLIANCE_ID:
+                    EveManager.update_corporation_info(corpinfo['id'], corpinfo['members']['current'], alliance, False)
+                else:
+                    if int(alliance.alliance_id) in alliance_standings['alliance']:
+                        if int(alliance_standings['alliance'][int(alliance.alliance_id)][
+                            'standing']) >= settings.ALLIANCE_BLUE_STANDING:
+                            EveManager.update_corporation_info(corpinfo['id'], corpinfo['members']['current'], alliance,
+                                                               True)
+                        else:
+                            EveManager.update_corporation_info(corpinfo['id'], corpinfo['members']['current'], alliance,
+                                                               False)
+                    else:
+                        EveManager.update_corporation_info(corpinfo['id'], corpinfo['members']['current'], alliance,
+                                                           False)
+            else:
+                if int(all_corp_info.corporation_id) in alliance_standings['alliance']:
+                    if int(alliance_standings['alliance'][int(all_corp_info.corporation_id)][
+                        'standing']) >= settings.ALLIANCE_BLUE_STANDING:
+                        EveManager.update_corporation_info(corpinfo['id'], corpinfo['members']['current'], None, True)
+                    else:
+                        EveManager.update_corporation_info(corpinfo['id'], corpinfo['members']['current'], None, False)
+                else:
+                    EveManager.update_corporation_info(corpinfo['id'], corpinfo['members']['current'], None, False)
+
+        # Nuke the none believers
+        # Check the corps
+        for all_corp_info in EveManager.get_all_corporation_info():
+            if all_corp_info.alliance is not None:
+                if all_corp_info.alliance.alliance_id != settings.ALLIANCE_ID:
+                    if not all_corp_info.is_blue:
+                        all_corp_info.delete()
+            else:
+                if not all_corp_info.is_blue:
+                    all_corp_info.delete()
+
+        # Check the alliances
+        for all_alliance_info in EveManager.get_all_alliance_info():
+            if all_alliance_info.alliance_id != settings.ALLIANCE_ID:
+                if not all_alliance_info.is_blue:
+                    all_alliance_info.delete()
+
+

eveonline/forms.py

@@ -7,17 +7,25 @@ from eveonline.managers import EveManager
 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")
+    is_blue = forms.BooleanField(label="Blue to alliance", required=False)
 
     def clean(self):
         if EveManager.check_if_api_key_pair_exist(self.cleaned_data['api_id']):
             raise forms.ValidationError(u'API key already exist')
 
-        if not EveApiManager.check_api_is_type_account(self.cleaned_data['api_id'],
+        check_blue = False
-                                                       self.cleaned_data['api_key']):
+        try:
-            raise forms.ValidationError(u'API not of type account')
+            check_blue = self.cleaned_data['is_blue']
+        except:
+            pass
 
-        if not EveApiManager.check_api_is_full(self.cleaned_data['api_id'],
+        if not check_blue:
-                                               self.cleaned_data['api_key']):
+            if not EveApiManager.check_api_is_type_account(self.cleaned_data['api_id'],
-            raise forms.ValidationError(u'API supplied is not a full api key')
+                                                           self.cleaned_data['api_key']):
+                raise forms.ValidationError(u'API not of type account')
+
+            if not EveApiManager.check_api_is_full(self.cleaned_data['api_id'],
+                                                   self.cleaned_data['api_key']):
+                raise forms.ValidationError(u'API supplied is not a full api key')
 
         return self.cleaned_data

eveonline/managers.py

@@ -68,7 +68,7 @@ class EveManager:
 
     @staticmethod
     def create_alliance_info(alliance_id, alliance_name, alliance_ticker, alliance_executor_corp_id,
-                             alliance_member_count):
+                             alliance_member_count, is_blue):
         if not EveManager.check_if_alliance_exists_by_id(alliance_id):
             alliance_info = EveAllianceInfo()
             alliance_info.alliance_id = alliance_id
@@ -76,33 +76,38 @@ class EveManager:
             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()
 
     @staticmethod
-    def update_alliance_info(alliance_id, alliance_executor_corp_id, alliance_member_count):
+    def update_alliance_info(alliance_id, alliance_executor_corp_id, alliance_member_count, is_blue):
         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()
 
     @staticmethod
-    def create_corporation_info(corp_id, corp_name, corp_ticker, corp_member_count, alliance):
+    def create_corporation_info(corp_id, corp_name, corp_ticker, corp_member_count, is_blue, alliance):
         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.alliance = alliance
+            corp_info.is_blue = is_blue
+            if alliance:
+                corp_info.alliance = alliance
             corp_info.save()
 
     @staticmethod
-    def update_corporation_info(corp_id, corp_member_count, alliance):
+    def update_corporation_info(corp_id, corp_member_count, alliance, is_blue):
         if EveManager.check_if_corporation_exists_by_id(corp_id):
-            corp_info = EveCorporationInfo.objects.get(corporation_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()
 
     @staticmethod
@@ -194,7 +199,10 @@ class EveManager:
         else:
             return None
 
-
     @staticmethod
     def get_all_corporation_info():
-        return EveCorporationInfo.objects.all()
+        return EveCorporationInfo.objects.all()
+
+    @staticmethod
+    def get_all_alliance_info():
+        return EveAllianceInfo.objects.all()

eveonline/models.py

@@ -31,6 +31,7 @@ class EveAllianceInfo(models.Model):
     alliance_name = models.CharField(max_length=254)
     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):
@@ -42,8 +43,8 @@ class EveCorporationInfo(models.Model):
     corporation_name = models.CharField(max_length=254)
     corporation_ticker = models.CharField(max_length=254)
     member_count = models.IntegerField()
-
+    is_blue = models.BooleanField(default=False)
-    alliance = models.ForeignKey(EveAllianceInfo)
+    alliance = models.ForeignKey(EveAllianceInfo, blank=True, null=True)
 
     def __str__(self):
         return self.corporation_name

eveonline/views.py

@@ -17,6 +17,21 @@ from util.common_task import deactivate_services
 from util.common_task import generate_corp_group_name
 
 
+def disable_alliance_member(user, char_id):
+    remove_member_permission(user, 'alliance_member')
+    remove_user_from_group(user, settings.DEFAULT_ALLIANCE_GROUP)
+    remove_user_from_group(user,
+                           generate_corp_group_name(
+                               EveManager.get_character_by_id(char_id).corporation_name))
+    deactivate_services(user)
+
+
+def disable_blue_member(user):
+    remove_member_permission(user, 'blue_member')
+    remove_user_from_group(user, settings.DEFAULT_BLUE_GROUP)
+    deactivate_services(user)
+
+
 @login_required
 def add_api_key(request):
     if request.method == 'POST':
@@ -57,7 +72,10 @@ def api_key_removal(request, api_id):
             if character.character_id == authinfo.main_char_id:
                 if character.api_id == api_id:
                     # TODO: Remove servies also
-                    AuthServicesInfoManager.update_main_char_Id("", request.user)
+                    if authinfo.is_blue:
+                        disable_blue_member(request.user)
+                    else:
+                        disable_alliance_member(request.user, authinfo.main_char_id)
 
     EveManager.delete_api_key_pair(api_id, request.user.id)
     EveManager.delete_characters_by_api_id(api_id, request.user.id)
@@ -78,20 +96,26 @@ def main_character_change(request, char_id):
         previousmainid = AuthServicesInfoManager.get_auth_service_info(request.user).main_char_id
         AuthServicesInfoManager.update_main_char_Id(char_id, request.user)
         # Check if character is in the alliance
+        character_info = EveManager.get_character_by_id(char_id)
+        corporation_info = EveManager.get_corporation_info_by_id(character_info.corporation_id)
+
         if EveManager.get_charater_alliance_id_by_id(char_id) == settings.ALLIANCE_ID:
             add_member_permission(request.user, 'alliance_member')
             add_user_to_group(request.user, settings.DEFAULT_ALLIANCE_GROUP)
             add_user_to_group(request.user,
                               generate_corp_group_name(EveManager.get_character_by_id(char_id).corporation_name))
+
+        elif corporation_info.is_blue:
+            add_member_permission(request.user, 'blue_member')
+            add_user_to_group(request.user, settings.DEFAULT_BLUE_GROUP)
+
         else:
             # TODO: disable serivces
             if check_if_user_has_permission(request.user, 'alliance_member'):
-                remove_member_permission(request.user, 'alliance_member')
+                disable_alliance_member(request.user, previousmainid)
-                remove_user_from_group(request.user, settings.DEFAULT_ALLIANCE_GROUP)
+
-                remove_user_from_group(request.user,
+            if check_if_user_has_permission(request.user, 'blue_member'):
-                                       generate_corp_group_name(
+                disable_blue_member(request.user)
-                                           EveManager.get_character_by_id(previousmainid).corporation_name))
-                deactivate_services(request.user)
 
         return HttpResponseRedirect("/characters")
     return HttpResponseRedirect("/characters")

groupmanagement/__init__.py

@@ -1,3 +0,0 @@
-from util import bootstrap_permissions
-
-bootstrap_permissions()

hrapplications/forms.py

@@ -1,4 +1,5 @@
 from django import forms
+from django.conf import settings
 
 from eveonline.models import EveCorporationInfo
 
@@ -6,7 +7,9 @@ from eveonline.models import EveCorporationInfo
 class HRApplicationForm(forms.Form):
     allchoices = []
     for corp in EveCorporationInfo.objects.all():
-        allchoices.append((str(corp.corporation_id), str(corp.corporation_name)))
+        if corp.alliance is not None:
+            if corp.alliance.alliance_id == settings.ALLIANCE_ID:
+                allchoices.append((str(corp.corporation_id), str(corp.corporation_name)))
 
     character_name = forms.CharField(max_length=254, required=True, label="Main Character Name")
     full_api_id = forms.CharField(max_length=254, required=True, label="API ID")

services/managers/eve_api_manager.py

@@ -2,6 +2,8 @@ import evelink.api
 import evelink.char
 import evelink.eve
 
+from django.conf import settings
+
 
 class EveApiManager():
     def __init__(self):
@@ -105,7 +107,7 @@ class EveApiManager():
         try:
             api = evelink.api.API(api_key=(api_id, api_key))
             account = evelink.account.Account(api=api)
-            info = account.status()
+            info = account.key_info()
             return True
         except evelink.api.APIError as error:
             return False
@@ -122,4 +124,58 @@ class EveApiManager():
         except evelink.api.APIError as error:
             return False
 
+        return False
+
+    @staticmethod
+    def check_if_id_is_corp(corp_id):
+        try:
+            api = evelink.api.API()
+            corp = evelink.corp.Corp(api=api)
+            corpinfo = corp.corporation_sheet(corp_id=int(corp_id))
+            results = corpinfo[0]
+            return True
+        except evelink.api.APIError as error:
+            return False
+
+        return False
+
+    @staticmethod
+    def get_alliance_standings():
+        if settings.ALLIANCE_EXEC_CORP_ID != "":
+            try:
+                api = evelink.api.API(api_key=(settings.ALLIANCE_EXEC_CORP_ID, settings.ALLIANCE_EXEC_CORP_VCODE))
+                corp = evelink.corp.Corp(api=api)
+                corpinfo = corp.contacts()
+                results = corpinfo[0]
+                return results
+            except evelink.api.APIError as error:
+                pass
+
+        return {}
+
+    @staticmethod
+    def check_if_id_is_alliance(alliance_id):
+        try:
+            api = evelink.api.API()
+            eve = evelink.eve.EVE(api=api)
+            alliance = eve.alliances()
+            results = alliance[0][int(alliance_id)]
+            if results:
+                return True
+        except evelink.api.APIError as error:
+            return False
+
+        return False
+
+    @staticmethod
+    def check_if_id_is_character(character_id):
+        try:
+            api = evelink.api.API()
+            eve = evelink.eve.EVE(api=api)
+            results = eve.character_info_from_id(character_id)
+            if results:
+                return True
+        except evelink.api.APIError as error:
+            return False
+
         return False

services/managers/mumble_manager.py

@@ -56,6 +56,10 @@ class MumbleManager:
     def __generate_username(username, corp_ticker):
         return "[" + corp_ticker + "]" + username
 
+    @staticmethod
+    def __generate_username_blue(username, corp_ticker):
+        return "[BLUE][" + corp_ticker + "]" + username
+
     @staticmethod
     def _gen_pwhash(password):
         return hashlib.sha1(password).hexdigest()
@@ -133,6 +137,26 @@ class MumbleManager:
 
             return "", ""
 
+    @staticmethod
+    def create_blue_user(corp_ticker, username):
+        dbcursor = connections['mumble'].cursor()
+        username_clean = MumbleManager.__generate_username_blue(MumbleManager.__santatize_username(username),
+                                                                corp_ticker)
+        password = MumbleManager.__generate_random_pass()
+        pwhash = MumbleManager._gen_pwhash(password)
+
+        try:
+            dbcursor.execute(MumbleManager.SQL_SELECT_USER_MAX_ID)
+            user_id = dbcursor.fetchone()[0]
+
+            dbcursor.execute(MumbleManager.SQL_CREATE_USER,
+                             [settings.MUMBLE_SERVER_ID, user_id, username_clean, pwhash])
+
+            return username_clean, password
+        except:
+
+            return "", ""
+
     @staticmethod
     def check_user_exist(username):
         dbcursor = connections['mumble'].cursor()

services/views.py

@@ -157,6 +157,20 @@ def activate_mumble(request):
     return HttpResponseRedirect("/dashboard")
 
 
+@login_required
+@permission_required('auth.blue_member')
+def activate_blue_mumble(request):
+    authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
+    character = EveManager.get_character_by_id(authinfo.main_char_id)
+    result = MumbleManager.create_blue_user(character.corporation_ticker, character.character_name)
+    # if its empty we failed
+    if result[0] is not "":
+        AuthServicesInfoManager.update_user_mumble_info(result[0], result[1], request.user)
+        update_mumble_groups(request.user)
+        return HttpResponseRedirect("/services/")
+    return HttpResponseRedirect("/dashboard")
+
+
 @login_required
 @permission_required('auth.alliance_member')
 def deactivate_mumble(request):
@@ -169,6 +183,18 @@ def deactivate_mumble(request):
     return HttpResponseRedirect("/")
 
 
+@login_required
+@permission_required('auth.blue_member')
+def deactivate_blue_mumble(request):
+    authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
+    result = MumbleManager.delete_user(authinfo.mumble_username)
+    # if false we failed
+    if result:
+        AuthServicesInfoManager.update_user_mumble_info("", "", request.user)
+        return HttpResponseRedirect("/services/")
+    return HttpResponseRedirect("/")
+
+
 @login_required
 @permission_required('auth.alliance_member')
 def reset_mumble_password(request):
@@ -178,4 +204,16 @@ def reset_mumble_password(request):
     if result != "":
         AuthServicesInfoManager.update_user_mumble_info(authinfo.mumble_username, result, request.user)
         return HttpResponseRedirect("/services/")
-    return HttpResponseRedirect("/")
+    return HttpResponseRedirect("/")
+
+
+@login_required
+@permission_required('auth.blue_member')
+def reset_mumble_password(request):
+    authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
+    result = MumbleManager.update_user_password(authinfo.mumble_username)
+    # if blank we failed
+    if result != "":
+        AuthServicesInfoManager.update_user_mumble_info(authinfo.mumble_username, result, request.user)
+        return HttpResponseRedirect("/services/")
+    return HttpResponseRedirect("/")

templates/registered/addapikey.html

@@ -17,10 +17,28 @@
                     <p class="text-center">
                         Full API Key is required for auth services
                     </p>
-                    <a target="_blank"
+
-                       href="https://community.eveonline.com/support/api-key/CreatePredefined?accessMask=268435455">Create
+                    <p class="text-center">
-                        a full API key</a>
+                        <a target="_blank"
+                           href="https://community.eveonline.com/support/api-key/CreatePredefined?accessMask=268435455">Create
+                            a full API key</a>
                     </p>
+
+                    <p class="text-center">
+                        NOTE: If you are part of the alliance do not check "Blue" this is for people who are blue to the
+                        alliance
+                        but are not in it. Blue access is limited.
+                    </p>
+
+                    <p class="text-center"><b>Do not change the accessmask or deselect options or it will not work </b>
+                    </p>
+
+                    <p class="text-center">
+                        <a target="_blank"
+                           href="https://community.eveonline.com/support/api-key/CreatePredefined?accessMask=8388608">Create
+                            a blue key</a>
+                    </p>
+
                     <form class="form-signin" role="form" action="{% url 'auth_add_api_key' %}" method="POST">
                         {% csrf_token %}
                         {{ form|bootstrap }}

templates/registered/services.html

@@ -9,7 +9,40 @@
 {% block content %}
     <div class="col-lg-12">
         <h1 class="page-header text-center">Available Services</h1>
-        {% if perms.auth.alliance_member %}
+        {% if perms.auth.blue_member %}
+            <table class="table table-bordered">
+                <tr>
+                    <th class="text-center">Service</th>
+                    <th class="text-center">Username</th>
+                    <th class="text-center">Password</th>
+                    <th class="text-center">Domain</th>
+                    <th class="text-center">Action</th>
+                </tr>
+                <tr>
+                    <td class="text-center">Mumble</td>
+                    <td class="text-center">{{ authinfo.mumble_username }}</td>
+                    <td class="text-center">{{ authinfo.mumble_password }}</td>
+                    <td class="text-center">{{ MUMBLE_URL }}</td>
+                    <td class="text-center">
+                        {% ifequal authinfo.mumble_username "" %}
+                            <a href="{% url 'auth_activate_blue_mumble' %}">
+                                <button type="button" class="btn btn-success"><span
+                                        class="glyphicon glyphicon-ok"></span></button>
+                            </a>
+                        {% else %}
+                            <a href="{% url 'auth_reset_mumble_password' %}">
+                                <button type="button" class="btn btn-primary"><span
+                                        class="glyphicon glyphicon-refresh"></span></button>
+                            </a>
+                            <a href="{% url 'auth_deactivate_blue_mumble' %}">
+                                <button type="button" class="btn btn-danger"><span
+                                        class="glyphicon glyphicon-remove"></span></button>
+                            </a>
+                        {% endifequal %}
+                    </td>
+                </tr>
+            </table>
+        {% elif perms.auth.alliance_member %}
             <table class="table table-bordered">
                 <tr>
                     <th class="text-center">Service</th>

util/__init__.py

@@ -1,35 +1,40 @@
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.auth.models import User
+from django.contrib.auth.models import Group
 from django.contrib.auth.models import Permission
+from django.conf import settings
 
 
 def bootstrap_permissions():
     ct = ContentType.objects.get_for_model(User)
+    Permission.objects.get_or_create(codename="alliance_member", content_type=ct, name="alliance_member")
     Permission.objects.get_or_create(codename="group_management", content_type=ct, name="group_management")
     Permission.objects.get_or_create(codename="jabber_broadcast", content_type=ct, name="jabber_broadcast")
     Permission.objects.get_or_create(codename="human_resources", content_type=ct, name="human_resources")
+    Permission.objects.get_or_create(codename="blue_member", content_type=ct, name="blue_member")
+    Group.objects.get_or_create(name=settings.DEFAULT_ALLIANCE_GROUP)
+    Group.objects.get_or_create(name=settings.DEFAULT_BLUE_GROUP)
 
 
 def add_member_permission(user, permission):
     ct = ContentType.objects.get_for_model(User)
     stored_permission, created = Permission.objects.get_or_create(codename=permission,
                                                                   content_type=ct, name=permission)
-
+    user = User.objects.get(username=user.username)
-    if User.objects.filter(username=user.username).exists():
+    user.user_permissions.add(stored_permission)
-        user = User.objects.get(username=user.username)
+    user.save()
-        user.user_permissions.add(stored_permission)
-        user.save()
 
 
 def remove_member_permission(user, permission):
     ct = ContentType.objects.get_for_model(User)
     stored_permission, created = Permission.objects.get_or_create(codename=permission,
                                                                   content_type=ct, name=permission)
-    if User.objects.filter(username=user.username).exists():
+
-        user = User.objects.get(username=user.username)
+    user = User.objects.get(username=user.username)
-        if user.has_perm(permission):
+
-            user.user_permissions.remove(stored_permission)
+    if user.has_perm('auth.' + permission):
-            user.save()
+        user.user_permissions.remove(stored_permission)
+        user.save()
 
 
 def check_if_user_has_permission(user, permission):