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

Merge branch 'master' of https://github.com/orbitroom/allianceauth

Browse Source
This commit is contained in:
orbitroom
2016-03-23 01:44:08 -04:00
parent faf5c473d8 51e3c287b6
commit 90a68cda21
28 changed files with 2660 additions and 1158 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
services/admin.py
View File

@@ -1,6 +1,7 @@
from django.contrib import admin
from .models import AuthTS
from .models import DiscordAuthToken
from .models import MumbleUser
class AuthTSgroupAdmin(admin.ModelAdmin):
fields = ['auth_group','ts_group']
@@ -9,3 +10,5 @@ class AuthTSgroupAdmin(admin.ModelAdmin):
admin.site.register(AuthTS, AuthTSgroupAdmin)
admin.site.register(DiscordAuthToken)
admin.site.register(MumbleUser)

146
services/managers/eve_api_manager.py
View File

@@ -16,14 +16,10 @@ class EveApiManager():
def get_characters_from_api(api_id, api_key):
chars = []
logger.debug("Getting characters from api id %s" % api_id)
try:
api = evelink.api.API(api_key=(api_id, api_key))
# Should get characters
account = evelink.account.Account(api=api)
chars = account.characters()
except evelink.api.APIError as error:
logger.exception("Unhandled APIError occured.")
api = evelink.api.API(api_key=(api_id, api_key))
# Should get characters
account = evelink.account.Account(api=api)
chars = account.characters()
logger.debug("Retrieved characters %s from api id %s" % (chars, api_id))
return chars
@@ -31,15 +27,11 @@ class EveApiManager():
def get_corporation_ticker_from_id(corp_id):
logger.debug("Getting ticker for corp id %s" % corp_id)
ticker = ""
try:
api = evelink.api.API()
corp = evelink.corp.Corp(api)
response = corp.corporation_sheet(corp_id)
logger.debug("Retrieved corp sheet for id %s: %s" % (corp_id, response))
ticker = response[0]['ticker']
except evelink.api.APIError as error:
logger.exception("Unhandled APIError occured.")
api = evelink.api.API()
corp = evelink.corp.Corp(api)
response = corp.corporation_sheet(corp_id)
logger.debug("Retrieved corp sheet for id %s: %s" % (corp_id, response))
ticker = response[0]['ticker']
logger.debug("Determined corp id %s ticker: %s" % (corp_id, ticker))
return ticker
@@ -47,13 +39,10 @@ class EveApiManager():
def get_alliance_information(alliance_id):
results = {}
logger.debug("Getting info for alliance with id %s" % alliance_id)
try:
api = evelink.api.API()
eve = evelink.eve.EVE(api=api)
alliance = eve.alliances()
results = alliance[0][int(alliance_id)]
except evelink.api.APIError as error:
logger.exception("Unhandled APIError occured.")
api = evelink.api.API()
eve = evelink.eve.EVE(api=api)
alliance = eve.alliances()
results = alliance[0][int(alliance_id)]
logger.debug("Got alliance info %s" % results)
return results
@@ -61,88 +50,57 @@ class EveApiManager():
def get_corporation_information(corp_id):
logger.debug("Getting info for corp with id %s" % corp_id)
results = {}
try:
api = evelink.api.API()
corp = evelink.corp.Corp(api=api)
corpinfo = corp.corporation_sheet(corp_id=int(corp_id))
results = corpinfo[0]
except evelink.api.APIError as error:
logger.exception("Unhandled APIError occured.")
api = evelink.api.API()
corp = evelink.corp.Corp(api=api)
corpinfo = corp.corporation_sheet(corp_id=int(corp_id))
results = corpinfo[0]
logger.debug("Got corp info %s" % results)
return results
@staticmethod
def check_api_is_type_account(api_id, api_key):
logger.debug("Checking if api id %s is account." % api_id)
try:
api = evelink.api.API(api_key=(api_id, api_key))
account = evelink.account.Account(api=api)
info = account.key_info()
logger.debug("API id %s is type %s" % (api_id, info[0]['type']))
return info[0]['type'] == "account"
except evelink.api.APIError as error:
logger.exception("Unhandled APIError occured.")
return None
api = evelink.api.API(api_key=(api_id, api_key))
account = evelink.account.Account(api=api)
info = account.key_info()
logger.debug("API id %s is type %s" % (api_id, info[0]['type']))
return info[0]['type'] == "account"
@staticmethod
def check_api_is_full(api_id, api_key):
logger.debug("Checking if api id %s meets member requirements." % api_id)
try:
api = evelink.api.API(api_key=(api_id, api_key))
account = evelink.account.Account(api=api)
info = account.key_info()
logger.debug("API has mask %s, required is %s" % (info[0]['access_mask'], settings.MEMBER_API_MASK))
return info[0]['access_mask'] & int(settings.MEMBER_API_MASK) == int(settings.MEMBER_API_MASK)
except evelink.api.APIError as error:
logger.exception("Unhandled APIError occured.")
return None
api = evelink.api.API(api_key=(api_id, api_key))
account = evelink.account.Account(api=api)
info = account.key_info()
logger.debug("API has mask %s, required is %s" % (info[0]['access_mask'], settings.MEMBER_API_MASK))
return info[0]['access_mask'] & int(settings.MEMBER_API_MASK) == int(settings.MEMBER_API_MASK)
@staticmethod
def check_blue_api_is_full(api_id, api_key):
logger.debug("Checking if api id %s meets blue requirements." % api_id)
try:
api = evelink.api.API(api_key=(api_id, api_key))
account = evelink.account.Account(api=api)
info = account.key_info()
logger.debug("API has mask %s, required is %s" % (info[0]['access_mask'], settings.BLUE_API_MASK))
return info[0]['access_mask'] & int(settings.BLUE_API_MASK) == int(settings.BLUE_API_MASK)
api = evelink.api.API(api_key=(api_id, api_key))
account = evelink.account.Account(api=api)
info = account.key_info()
logger.debug("API has mask %s, required is %s" % (info[0]['access_mask'], settings.BLUE_API_MASK))
return info[0]['access_mask'] & int(settings.BLUE_API_MASK) == int(settings.BLUE_API_MASK)
except evelink.api.APIError as error:
logger.exception("Unhandled APIError occured.")
return None
@staticmethod
def get_api_info(api_id, api_key):
logger.debug("Getting api info for key id %s" % api_id)
try:
api = evelink.api.API(api_key=(api_id, api_key))
account = evelink.account.Account(api=api)
info = account.key_info()
logger.debug("Got info for api id %s: %s" % (api_id, info))
return info
except evelink.api.APIError as error:
logger.exception("Unhandled APIError occured.")
return None
api = evelink.api.API(api_key=(api_id, api_key))
account = evelink.account.Account(api=api)
info = account.key_info()
logger.debug("Got info for api id %s: %s" % (api_id, info))
return info
@staticmethod
def api_key_is_valid(api_id, api_key):
logger.debug("Checking if api id %s is valid." % api_id)
try:
api = evelink.api.API(api_key=(api_id, api_key))
account = evelink.account.Account(api=api)
info = account.key_info()
logger.info("Verified api id %s is still valid." % api_id)
return True
except evelink.api.APIError as error:
logger.exception("APIError occured while validating api id %s" % api_id)
logger.info("API id %s is invalid." % api_id)
return False
api = evelink.api.API(api_key=(api_id, api_key))
account = evelink.account.Account(api=api)
info = account.key_info()
logger.info("Verified api id %s is still valid." % api_id)
return True
@staticmethod
def check_if_api_server_online():
@@ -170,6 +128,9 @@ class EveApiManager():
logger.debug("Confirmed id %s is a corp." % corp_id)
return True
except evelink.api.APIError as error:
if int(error.code) == '523':
logger.debug("Confirmed id %s is not a corp" % corp_id)
return False
logger.debug("APIError occured while checking if id %s is corp. Possibly not corp?" % corp_id)
logger.debug("Unable to verify id %s is corp." % corp_id)
@@ -178,16 +139,13 @@ class EveApiManager():
@staticmethod
def get_corp_standings():
if settings.CORP_API_ID and settings.CORP_API_VCODE:
try:
logger.debug("Getting corp standings with api id %s" % settings.CORP_API_ID)
api = evelink.api.API(api_key=(settings.CORP_API_ID, settings.CORP_API_VCODE))
corp = evelink.corp.Corp(api=api)
corpinfo = corp.contacts()
results = corpinfo.result
logger.debug("Got corp standings from settings: %s" % results)
return results
except evelink.api.APIError as error:
logger.exception("Unhandled APIError occured.", exc_info=True)
logger.debug("Getting corp standings with api id %s" % settings.CORP_API_ID)
api = evelink.api.API(api_key=(settings.CORP_API_ID, settings.CORP_API_VCODE))
corp = evelink.corp.Corp(api=api)
corpinfo = corp.contacts()
results = corpinfo.result
logger.debug("Got corp standings from settings: %s" % results)
return results
else:
logger.error("No corp API key supplied in settings. Unable to get standings.")
return {}

234
services/managers/mumble_manager.py
View File

@@ -6,46 +6,13 @@ import django
from django.db import connections
from django.conf import settings
from services.models import MumbleUser
import logging
logger = logging.getLogger(__name__)
class MumbleManager:
SQL_SELECT_USER_MAX_ID = r"SELECT max(user_id)+1 as next_id from murmur_users"
SQL_SELECT_GROUP_MAX_ID = r"SELECT MAX(group_id)+1 FROM murmur_groups"
SQL_CREATE_USER = r"INSERT INTO murmur_users (server_id, user_id, name, pw) VALUES (%s, %s, %s, %s)"
SQL_SELECT_GET_USER_ID_BY_NAME = r"SELECT user_id from murmur_users WHERE name = %s AND server_id = %s"
SQL_CHECK_USER_EXIST = r"SELECT name from murmur_users WHERE name = %s AND server_id = %s"
SQL_DELETE_USER = r"DELETE FROM murmur_users WHERE name = %s AND server_id = %s"
SQL_UPDATE_USER_PASSWORD = r"UPDATE murmur_users SET pw = %s WHERE name = %s AND server_id = %s"
SQL_GET_GROUPS = r"SELECT group_id, name FROM murmur_groups WHERE server_id = %s AND channel_id = 0"
SQL_GET_GROUP_FROM_NAME = r"SELECT group_id, name FROM murmur_groups " \
r"WHERE server_id = %s AND channel_id = 0 AND name = %s"
SQL_GET_USER_GROUPS = r"SELECT murmur_groups.name FROM murmur_groups, murmur_group_members WHERE " \
r"murmur_group_members.group_id = murmur_groups.group_id AND " \
r"murmur_group_members.server_id = murmur_groups.server_id AND " \
r"murmur_group_members.user_id = %s"
SQL_ADD_GROUP = r"INSERT INTO murmur_groups (group_id, server_id, name, channel_id, inherit, inheritable) " \
r"VALUES (%s, %s, %s, 0, 1, 1)"
SQL_ADD_USER_TO_GROUP = r"INSERT INTO murmur_group_members (group_id, server_id, user_id, addit) " \
r"VALUES (%s, %s, %s, 1)"
SQL_DELETE_USER_FROM_GROUP = r"DELETE FROM murmur_group_members WHERE group_id = %s " \
r"AND server_id = %s AND user_id = %s"
def __init__(self):
pass
@staticmethod
def __santatize_username(username):
@@ -69,192 +36,81 @@ class MumbleManager:
def _gen_pwhash(password):
return hashlib.sha1(password).hexdigest()
@staticmethod
def _get_groups():
dbcursor = connections['mumble'].cursor()
dbcursor.execute(MumbleManager.SQL_GET_GROUPS, [settings.MUMBLE_SERVER_ID])
rows = dbcursor.fetchall()
out = {}
for row in rows:
out[row[1]] = row[0]
logger.debug("Got mumble groups %s" % out)
return out
@staticmethod
def _get_group(name):
logger.debug("Looking for group name %s in mumble." % name)
dbcursor = connections['mumble'].cursor()
dbcursor.execute(MumbleManager.SQL_GET_GROUP_FROM_NAME, [settings.MUMBLE_SERVER_ID, name])
row = dbcursor.fetchone()
if row:
logger.debug("Found group %s in mumble - %s" % (name, row[0]))
return row[0]
@staticmethod
def _get_user_groups(name):
logger.debug("Getting mumble groups for username %s" % name)
dbcursor = connections['mumble'].cursor()
user_id = MumbleManager.get_user_id_by_name(name)
dbcursor.execute(MumbleManager.SQL_GET_USER_GROUPS, [user_id])
out = [row[0] for row in dbcursor.fetchall()]
logger.debug("Got user %s mumble groups %s" % (name, out))
return out
@staticmethod
def _add_group(name):
logger.debug("Adding group %s to mumble server." % name)
dbcursor = connections['mumble'].cursor()
dbcursor.execute(MumbleManager.SQL_SELECT_GROUP_MAX_ID)
row = dbcursor.fetchone()
groupid = row[0]
dbcursor.execute(MumbleManager.SQL_ADD_GROUP, [groupid, settings.MUMBLE_SERVER_ID, name])
logger.info("Created group %s on mumble server with id %s" % (name, groupid))
return groupid
@staticmethod
def _add_user_to_group(userid, groupid):
if userid != None:
dbcursor = connections['mumble'].cursor()
dbcursor.execute(MumbleManager.SQL_ADD_USER_TO_GROUP, [groupid, settings.MUMBLE_SERVER_ID, userid])
logger.info("Added user id %s to mumble group id %s" % (userid, groupid))
@staticmethod
def _del_user_from_group(userid, groupid):
dbcursor = connections['mumble'].cursor()
dbcursor.execute(MumbleManager.SQL_DELETE_USER_FROM_GROUP, [groupid, settings.MUMBLE_SERVER_ID, userid])
logger.info("Removed user id %s from mumble group id %s" % (userid, groupid))
@staticmethod
def get_user_id_by_name(name):
logger.debug("Getting mumble user id for user with name %s" % name)
dbcursor = connections['mumble'].cursor()
dbcursor.execute(MumbleManager.SQL_SELECT_GET_USER_ID_BY_NAME, [name, settings.MUMBLE_SERVER_ID])
row = dbcursor.fetchone()
if row:
logger.debug("Got mumble user id %s for name %s" % (row[0], name))
return row[0]
@staticmethod
def create_user(corp_ticker, username):
logger.debug("Creating mumble user with username %s and ticker %s" % (username, corp_ticker))
dbcursor = connections['mumble'].cursor()
username_clean = MumbleManager.__santatize_username(MumbleManager.__generate_username(username, corp_ticker))
password = MumbleManager.__generate_random_pass()
pwhash = MumbleManager._gen_pwhash(password)
logger.debug("Proceeding with mumble user creation: clean username %s, pwhash starts with %s" % (username_clean, pwhash[0:5]))
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])
logger.info("Added user to mumble with username %s" % username_clean)
if MumbleUser.objects.filter(username=username_clean).exists() is False:
logger.info("Creating mumble user %s" % username_clean)
model = MumbleUser.objects.create(username=username_clean, pwhash=pwhash)
return username_clean, password
else:
logger.warn("Mumble user %s already exists. Updating password")
model = MumbleUser.objects.get(username=username_clean)
model.pwhash = pwhash
model.save()
logger.info("Updated mumble user %s" % username_clean)
return username_clean, password
except django.db.utils.IntegrityError as error:
logger.exception("IntegrityError during mumble create_user occured.")
except:
logger.exception("Unhandled exception occured.")
logger.error("Exception prevented creation of mumble user. Returning blank for username, password.")
return "", ""
@staticmethod
def create_blue_user(corp_ticker, username):
logger.debug("Creating mumble blue user with username %s and ticker %s" % (username, corp_ticker))
dbcursor = connections['mumble'].cursor()
username_clean = MumbleManager.__santatize_username(MumbleManager.__generate_username_blue(username,
corp_ticker))
username_clean = MumbleManager.__santatize_username(MumbleManager.__generate_username_blue(username, corp_ticker))
password = MumbleManager.__generate_random_pass()
pwhash = MumbleManager._gen_pwhash(password)
logger.debug("Proceeding with mumble user creation: clean username %s, pwhash starts with %s" % (username_clean, pwhash[0:5]))
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])
logger.info("Added blue user to mumble with username %s" % username_clean)
if MumbleUser.objects.filter(username=username_clean).exists() is False:
logger.info("Creating mumble user %s" % username_clean)
model = MumbleUser.objects.create(username=username_clean, pwhash=pwhash)
return username_clean, password
else:
logger.warn("Mumble user %s already exists. Updating password")
model = MumbleUser.objects.get(username=username_clean)
model.pwhash = pwhash
model.save()
logger.info("Updated mumble user %s" % username_clean)
return username_clean, password
except:
logger.exception("Unhandled exception occured.")
logger.error("Exception prevented creation of mumble blue user. Returning blank for username, password.")
return "", ""
@staticmethod
def check_user_exist(username):
logger.debug("Checking if username %s exists on mumble." % username)
dbcursor = connections['mumble'].cursor()
dbcursor.execute(MumbleManager.SQL_CHECK_USER_EXIST,
[username, settings.MUMBLE_SERVER_ID])
row = dbcursor.fetchone()
if row and row[0].lower() == username.lower():
logger.debug("Found username %s on mumble." % username)
return True
logger.debug("Unable to find username %s on mumble." % username)
return False
@staticmethod
def delete_user(username):
logger.debug("Deleting user %s from mumble." % username)
dbcursor = connections['mumble'].cursor()
if MumbleManager.check_user_exist(username):
try:
dbcursor.execute(MumbleManager.SQL_DELETE_USER,
[username, settings.MUMBLE_SERVER_ID])
logger.info("Deleted user %s from mumble." % username)
return True
except:
logger.exception("Exception prevented deletion of user %s from mumble." % username)
return False
logger.error("User %s not found on mumble. Unable to delete." % username)
if MumbleUser.objects.filter(username=username).exists():
MumbleUser.objects.filter(username=username).delete()
logger.info("Deleted user %s from mumble" % username)
return True
logger.error("Unable to delete user %s from mumble: MumbleUser model not found" % username)
return False
@staticmethod
def update_user_password(username, password=None):
logger.debug("Updating mumble user %s password." % username)
dbcursor = connections['mumble'].cursor()
if not password:
password = MumbleManager.__generate_random_pass()
pwhash = MumbleManager._gen_pwhash(password)
logger.debug("Proceeding with mumble user %s password update - pwhash starts with %s" % (username, pwhash[0:5]))
if MumbleManager.check_user_exist(username):
try:
dbcursor.execute(MumbleManager.SQL_UPDATE_USER_PASSWORD,
[pwhash, username, settings.MUMBLE_SERVER_ID])
logger.info("Updated mumble user %s password." % username)
return password
except:
logger.exception("Exception prevented updating of mumble user %s password." % username)
return ""
if MumbleUser.objects.filter(username=username).exists():
model = MumbleUser.objects.get(username=username)
model.pwhash = pwhash
model.save()
return password
logger.error("User %s not found on mumble. Unable to update password." % username)
return ""
@staticmethod
def update_groups(username, groups):
logger.debug("Updating mumble user %s groups %s" % (username, groups))
userid = MumbleManager.get_user_id_by_name(username)
mumble_groups = MumbleManager._get_groups()
user_groups = set(MumbleManager._get_user_groups(username))
act_groups = set([g.replace(' ', '-') for g in groups])
addgroups = act_groups - user_groups
remgroups = user_groups - act_groups
logger.info("Updating mumble user %s groups - adding %s, removing %s" % (username, addgroups, remgroups))
for g in addgroups:
if not g in mumble_groups:
mumble_groups[g] = MumbleManager._add_group(g)
try:
logger.debug("Adding mumble user %s to group %s" % (userid, mumble_groups[g]))
MumbleManager._add_user_to_group(userid, mumble_groups[g])
except:
logger.exception("Exception occured while adding mumble user %s with id %s to group %s with id %s" % (username, userid, g, mumble_groups[g]))
for g in remgroups:
try:
logger.debug("Deleting mumble user %s from group %s" % (userid, mumble_groups[g]))
MumbleManager._del_user_from_group(userid, mumble_groups[g])
except:
logger.exception("Exception occured while removing mumble user %s with id %s from group %s with id %s" % (username, userid, g, mumble_groups[g]))
safe_groups = list(set([g.replace(' ', '-') for g in groups]))
groups =''
for g in safe_groups:
groups = groups + g + ','
groups = groups.strip(',')
if MumbleUser.objects.filter(username=username).exists():
logger.info("Updating mumble user %s groups to %s" % (username, safe_groups))
model = MumbleUser.objects.get(username=username)
model.groups = groups
model.save()
else:
logger.error("User %s not found on mumble. Unable to update groups." % username)

8
services/models.py
View File

@@ -38,3 +38,11 @@ class DiscordAuthToken(models.Model):
def __str__(self):
output = "Discord Token for email %s user %s" % (self.email, self.user)
return output.encode('utf-8')
class MumbleUser(models.Model):
username = models.CharField(max_length=254, unique=True)
pwhash = models.CharField(max_length=40)
groups = models.TextField(blank=True, null=True)
def __str__(self):
return self.username

3
services/tasks.py
View File

@@ -6,6 +6,7 @@ from services.models import UserTSgroup
from services.models import AuthTS
from services.models import TSgroup
from services.models import DiscordAuthToken
from services.models import MumbleUser
logger = logging.getLogger(__name__)
@@ -81,6 +82,8 @@ def disable_mumble():
auth.save()
logger.info("Deleting all SyncGroupCache models for mumble")
SyncGroupCache.objects.filter(servicename="mumble").delete()
logger.info("Deleting all MumbleUser models")
MumbleUser.objects.all().delete()
def disable_ipboard():
if settings.ENABLE_AUTH_IPBOARD:

25
services/views.py
View File

@@ -16,7 +16,6 @@ from managers.teamspeak3_manager import Teamspeak3Manager
from managers.discord_manager import DiscordManager
from authentication.managers import AuthServicesInfoManager
from eveonline.managers import EveManager
from celerytask.tasks import remove_all_syncgroups_for_service
from celerytask.tasks import update_jabber_groups
from celerytask.tasks import update_mumble_groups
from celerytask.tasks import update_forum_groups
@@ -135,7 +134,7 @@ def activate_forum(request):
if result[0] != "":
AuthServicesInfoManager.update_user_forum_info(result[0], result[1], request.user)
logger.debug("Updated authserviceinfo for user %s with forum credentials. Updating groups." % request.user)
update_forum_groups(request.user)
update_forum_groups.delay(request.user)
logger.info("Succesfully activated forum for user %s" % request.user)
return HttpResponseRedirect("/services/")
logger.error("Unsuccesful attempt to activate forum for user %s" % request.user)
@@ -148,7 +147,6 @@ def deactivate_forum(request):
logger.debug("deactivate_forum called by user %s" % request.user)
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
result = Phpbb3Manager.disable_user(authinfo.forum_username)
remove_all_syncgroups_for_service(request.user, "phpbb")
# false we failed
if result:
AuthServicesInfoManager.update_user_forum_info("", "", request.user)
@@ -185,7 +183,7 @@ def activate_ipboard_forum(request):
if result[0] != "":
AuthServicesInfoManager.update_user_ipboard_info(result[0], result[1], request.user)
logger.debug("Updated authserviceinfo for user %s with ipboard credentials. Updating groups." % request.user)
update_ipboard_groups(request.user)
update_ipboard_groups.delay(request.user)
logger.info("Succesfully activated ipboard for user %s" % request.user)
return HttpResponseRedirect("/services/")
logger.error("Unsuccesful attempt to activate ipboard for user %s" % request.user)
@@ -198,7 +196,6 @@ def deactivate_ipboard_forum(request):
logger.debug("deactivate_ipboard_forum called by user %s" % request.user)
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
result = IPBoardManager.disable_user(authinfo.ipboard_username)
remove_all_syncgroups_for_service(request.user, "ipboard")
# false we failed
if result:
AuthServicesInfoManager.update_user_ipboard_info("", "", request.user)
@@ -234,7 +231,7 @@ def activate_jabber(request):
if info[0] is not "":
AuthServicesInfoManager.update_user_jabber_info(info[0], info[1], request.user)
logger.debug("Updated authserviceinfo for user %s with jabber credentials. Updating groups." % request.user)
update_jabber_groups(request.user)
update_jabber_groups.delay(request.user)
logger.info("Succesfully activated jabber for user %s" % request.user)
return HttpResponseRedirect("/services/")
logger.error("Unsuccesful attempt to activate jabber for user %s" % request.user)
@@ -247,7 +244,6 @@ def deactivate_jabber(request):
logger.debug("deactivate_jabber called by user %s" % request.user)
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
result = OpenfireManager.delete_user(authinfo.jabber_username)
remove_all_syncgroups_for_service(request.user, "openfire")
# If our username is blank means we failed
if result:
AuthServicesInfoManager.update_user_jabber_info("", "", request.user)
@@ -288,7 +284,7 @@ def activate_mumble(request):
if result[0] is not "":
AuthServicesInfoManager.update_user_mumble_info(result[0], result[1], request.user)
logger.debug("Updated authserviceinfo for user %s with mumble credentials. Updating groups." % request.user)
update_mumble_groups(request.user)
update_mumble_groups.delay(request.user)
logger.info("Succesfully activated mumble for user %s" % request.user)
return HttpResponseRedirect("/services/")
logger.error("Unsuccessful attempt to activate mumble for user %s" % request.user)
@@ -301,7 +297,6 @@ def deactivate_mumble(request):
logger.debug("deactivate_mumble called by user %s" % request.user)
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
result = MumbleManager.delete_user(authinfo.mumble_username)
remove_all_syncgroups_for_service(request.user, "mumble")
# if false we failed
if result:
AuthServicesInfoManager.update_user_mumble_info("", "", request.user)
@@ -344,7 +339,7 @@ def activate_teamspeak3(request):
if result[0] is not "":
AuthServicesInfoManager.update_user_teamspeak3_info(result[0], result[1], request.user)
logger.debug("Updated authserviceinfo for user %s with TS3 credentials. Updating groups." % request.user)
update_teamspeak3_groups(request.user)
update_teamspeak3_groups.delay(request.user)
logger.info("Succesfully activated TS3 for user %s" % request.user)
return HttpResponseRedirect("/services/")
logger.error("Unsuccessful attempt to activate TS3 for user %s" % request.user)
@@ -358,8 +353,6 @@ def deactivate_teamspeak3(request):
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
result = Teamspeak3Manager.delete_user(authinfo.teamspeak3_uid)
remove_all_syncgroups_for_service(request.user, "teamspeak3")
# if false we failed
if result:
AuthServicesInfoManager.update_user_teamspeak3_info("", "", request.user)
@@ -378,8 +371,6 @@ def reset_teamspeak3_perm(request):
logger.debug("Deleting TS3 user for user %s" % request.user)
Teamspeak3Manager.delete_user(authinfo.teamspeak3_uid)
remove_all_syncgroups_for_service(request.user, "teamspeak3")
if check_if_user_has_permission(request.user, "blue_member"):
logger.debug("Generating new permission key for blue user %s with main character %s" % (request.user, character))
result = Teamspeak3Manager.generate_new_blue_permissionkey(authinfo.teamspeak3_uid, character.character_name,
@@ -393,7 +384,7 @@ def reset_teamspeak3_perm(request):
if result != "":
AuthServicesInfoManager.update_user_teamspeak3_info(result[0], result[1], request.user)
logger.debug("Updated authserviceinfo for user %s with TS3 credentials. Updating groups." % request.user)
update_teamspeak3_groups(request.user)
update_teamspeak3_groups.delay(request.user)
logger.info("Successfully reset TS3 permission key for user %s" % request.user)
return HttpResponseRedirect("/services/")
logger.error("Unsuccessful attempt to reset TS3 permission key for user %s" % request.user)
@@ -413,7 +404,6 @@ def deactivate_discord(request):
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
result = DiscordManager.delete_user(authinfo.discord_uid)
if result:
remove_all_syncgroups_for_service(request.user, "discord")
AuthServicesInfoManager.update_user_discord_info("", request.user)
logger.info("Succesfully deactivated discord for user %s" % request.user)
return HttpResponseRedirect("/services/")
@@ -453,7 +443,7 @@ def activate_discord(request):
if user_id != "":
AuthServicesInfoManager.update_user_discord_info(user_id, request.user)
logger.debug("Updated discord id %s for user %s" % (user_id, request.user))
update_discord_groups(request.user)
update_discord_groups.delay(request.user)
logger.debug("Updated discord groups for user %s." % request.user)
success = True
logger.info("Succesfully activated discord for user %s" % request.user)
@@ -592,4 +582,3 @@ def set_ipboard_password(request):
logger.debug("Rendering form for user %s" % request.user)
context = {'form': form, 'service': 'IPBoard', 'error': error}
return render_to_response('registered/service_password.html', context, context_instance=RequestContext(request))