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

Bulk of the profile work is done.

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

6
services/hooks.py
View File

@@ -1,11 +1,8 @@
from __future__ import unicode_literals
from django.template.loader import render_to_string
from django.utils.safestring import mark_safe
from alliance_auth.hooks import get_hooks
from authentication.states import MEMBER_STATE, BLUE_STATE
from authentication.models import AuthServicesInfo
class ServicesHook:
@@ -72,13 +69,12 @@ class ServicesHook:
def service_active_for_user(self, user):
pass
def show_service_ctrl(self, user, state):
def show_service_ctrl(self, user):
"""
Whether the service control should be displayed to the given user
who has the given service state. Usually this function wont
require overloading.
:param user: django.contrib.auth.models.User
:param state: auth user state
:return: bool True if the service should be shown
"""
return self.service_active_for_user(user) or user.is_superuser

0
services/management/__init__.py Normal file
View File

0
services/management/commands/__init__.py Normal file
View File

12
services/management/commands/verify_service_accounts.py Normal file
View File

@@ -0,0 +1,12 @@
from django.core.management.base import BaseCommand
from django.contrib.auth.models import User
from services.tasks import validate_services
class Command(BaseCommand):
help = "Ensures all service accounts belong to users with required permissions."
def handle(self, *args, **options):
for u in User.objects.all():
validate_services(u)
self.stdout.write(self.style.SUCCESS('Verified all user service accounts.'))

353
services/managers/eve_api_manager.py
View File

@@ -1,353 +0,0 @@
from __future__ import unicode_literals
import evelink.api
import evelink.char
import evelink.eve
from authentication.states import MEMBER_STATE, BLUE_STATE
from authentication.models import AuthServicesInfo
from eveonline.models import EveCharacter
from django.conf import settings
import requests
try:
from urllib2 import HTTPError, URLError
except ImportError: # py3
from urllib.error import URLError, HTTPError
import logging
logger = logging.getLogger(__name__)
class EveApiManager:
def __init__(self):
pass
class ApiValidationError(Exception):
def __init__(self, msg, api_id):
self.msg = msg
self.api_id = api_id
def __str__(self):
return self.msg
class ApiMaskValidationError(ApiValidationError):
def __init__(self, required_mask, api_mask, api_id):
msg = 'Insufficient API mask provided. Required: %s Got: %s' % (required_mask, api_mask)
self.required_mask = required_mask
self.api_mask = api_mask
super(EveApiManager.ApiMaskValidationError, self).__init__(msg, api_id)
class ApiAccountValidationError(ApiValidationError):
def __init__(self, api_id):
msg = 'Insufficient API access provided. Full account access is required, got character restricted.'
super(EveApiManager.ApiAccountValidationError, self).__init__(msg, api_id)
class ApiInvalidError(ApiValidationError):
def __init__(self, api_id):
msg = 'Key is invalid.'
super(EveApiManager.ApiInvalidError, self).__init__(msg, api_id)
class ApiServerUnreachableError(Exception):
def __init__(self, e):
self.error = e
def __str__(self):
return 'Unable to reach API servers: %s' % str(self.error)
@staticmethod
def get_characters_from_api(api_id, api_key):
logger.debug("Getting characters from api id %s" % api_id)
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
@staticmethod
def get_corporation_ticker_from_id(corp_id):
logger.debug("Getting ticker for corp id %s" % corp_id)
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
@staticmethod
def get_alliance_information(alliance_id):
logger.debug("Getting info for alliance with id %s" % alliance_id)
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
@staticmethod
def get_corporation_information(corp_id):
logger.debug("Getting info for corp with id %s" % corp_id)
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 get_api_info(api_id, api_key):
api = evelink.api.API(api_key=(api_id, api_key))
account = evelink.account.Account(api=api)
return account.key_info()[0]
@staticmethod
def check_api_is_type_account(api_id, api_key):
logger.debug("Checking if api id %s is account." % api_id)
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)
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)
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)
@staticmethod
def get_api_info(api_id, api_key):
logger.debug("Getting api info for key id %s" % api_id)
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)
api = evelink.api.API(api_key=(api_id, api_key))
account = evelink.account.Account(api=api)
account.key_info()
logger.info("Verified api id %s is still valid." % api_id)
return True
@staticmethod
def check_if_api_server_online():
logger.debug("Checking if API server online.")
try:
api = evelink.api.API()
server = evelink.server.Server(api=api)
server.server_status()
logger.info("Verified API server is online and reachable.")
return True
except evelink.api.APIError:
logger.exception("APIError occured while trying to query api server. Possibly offline?")
logger.warn("Unable to reach API server.")
return False
@staticmethod
def check_if_id_is_corp(corp_id):
logger.debug("Checking if id %s is a corp." % corp_id)
try:
api = evelink.api.API()
corp = evelink.corp.Corp(api=api)
corpinfo = corp.corporation_sheet(corp_id=int(corp_id))
assert corpinfo[0]
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)
return False
@staticmethod
def get_corp_standings():
if settings.CORP_API_ID and settings.CORP_API_VCODE:
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.debug("No corp API key supplied in settings. Unable to get standings.")
return {}
@staticmethod
def get_corp_membertracking(api, vcode):
try:
logger.debug("Getting corp membertracking with api id %s" % settings.CORP_API_ID)
api = evelink.api.API(api_key=(api, vcode))
corp = evelink.corp.Corp(api=api)
membertracking = corp.members()
results = membertracking.result
logger.debug("Got corp membertracking from settings: %s" % results)
return results
except evelink.api.APIError:
logger.exception("Unhandled APIError occured.")
return {}
@staticmethod
def check_if_id_is_alliance(alliance_id):
logger.debug("Checking if id %s is an alliance." % alliance_id)
try:
api = evelink.api.API()
eve = evelink.eve.EVE(api=api)
alliance = eve.alliances()
results = alliance.result[int(alliance_id)]
if results:
logger.debug("Confirmed id %s is an alliance." % alliance_id)
return True
except evelink.api.APIError:
logger.exception(
"APIError occured while checking if id %s is an alliance. Possibly not alliance?" % alliance_id)
except KeyError:
logger.debug("Alliance with id %s not found in active alliance list." % alliance_id)
return False
logger.debug("Unable to verify id %s is an an alliance." % alliance_id)
return False
@staticmethod
def check_if_id_is_character(character_id):
logger.debug("Checking if id %s is a character." % character_id)
try:
api = evelink.api.API()
eve = evelink.eve.EVE(api=api)
results = eve.character_info_from_id(character_id)
if results:
logger.debug("Confirmed id %s is a character." % character_id)
return True
except evelink.api.APIError:
logger.debug(
"APIError occured while checking if id %s is a character. Possibly not character?" % character_id,
exc_info=True)
logger.debug("Unable to verify id %s is a character." % character_id)
return False
@staticmethod
def check_if_alliance_exists(alliance_id):
logger.debug("Checking if alliance id %s exists." % alliance_id)
try:
api = evelink.api.API()
eve = evelink.eve.EVE(api=api)
alliances = eve.alliances()
if int(alliance_id) in alliances[0]:
logger.debug("Verified alliance id %s exists." % alliance_id)
return True
else:
logger.debug("Verified alliance id %s does not exist." % alliance_id)
return False
except evelink.api.APIError:
logger.exception("Unhandled APIError occured.")
return False
except ValueError:
# attempts to catch error resulting from checking alliance_of nonetype models
logger.exception("Unhandled ValueError occured. Possible nonetype alliance model.")
return False
except:
logger.warn("Exception prevented verification of alliance id %s existance. Assuming false." % alliance_id)
return False
@staticmethod
def check_if_corp_exists(corp_id):
logger.debug("Checking if corp id %s exists." % corp_id)
try:
api = evelink.api.API()
corp = evelink.corp.Corp(api=api)
corpinfo = corp.corporation_sheet(corp_id=corp_id)
if corpinfo[0]['members']['current'] > 0:
logger.debug(
"Verified corp id %s exists with member count %s" % (corp_id, corpinfo[0]['members']['current']))
return True
else:
logger.debug(
"Verified corp id %s has closed. Member count %s" % (corp_id, corpinfo[0]['members']['current']))
return False
except evelink.api.APIError:
# could be smart and check for error code523 to verify error due to no corp instead of catch-all
logger.exception("Unhandled APIError occured.")
return False
except:
logger.warn("Exception prevented verification of corp id %s existance. Assuming false." % corp_id)
return False
@staticmethod
def validate_member_api(api_id, api_key):
if settings.MEMBER_API_ACCOUNT:
if EveApiManager.check_api_is_type_account(api_id, api_key) is False:
logger.info("Api id %s is not type account as required for members - failed validation." % api_id)
return False
if EveApiManager.check_api_is_full(api_id, api_key) is False:
logger.info("Api id %s does not meet member access mask requirements - failed validation." % api_id)
return False
return True
@staticmethod
def validate_blue_api(api_id, api_key):
if settings.BLUE_API_ACCOUNT:
if EveApiManager.check_api_is_type_account(api_id, api_key) is False:
logger.info("Api id %s is not type account as required for blues - failed validation." % api_id)
return False
if EveApiManager.check_blue_api_is_full(api_id, api_key) is False:
logger.info("Api id %s does not meet minimum blue access mask requirements - failed validation." % api_id)
return False
return True
@staticmethod
def validate_api(api_id, api_key, user):
try:
info = EveApiManager.get_api_info(api_id, api_key).result
except evelink.api.APIError as e:
if int(e.code) == 222:
raise EveApiManager.ApiInvalidError(api_id)
raise e
except (requests.exceptions.RequestException, HTTPError, URLError) as e:
raise EveApiManager.ApiServerUnreachableError(e)
auth = AuthServicesInfo.objects.get(user=user)
states = [auth.state]
from authentication.tasks import determine_membership_by_character # circular import issue
chars = info['characters']
for char in chars:
evechar = EveCharacter()
evechar.character_name = chars[char]['name']
evechar.corporation_id = chars[char]['corp']['id']
evechar.alliance_id = chars[char]['alliance']['id']
states.append(determine_membership_by_character(evechar))
if MEMBER_STATE not in states and BLUE_STATE not in states:
# default to requiring member keys for applications
states.append(MEMBER_STATE)
logger.debug('Checking API %s for states %s' % (api_id, states))
for state in states:
if (state == MEMBER_STATE and settings.MEMBER_API_ACCOUNT) or (
state == BLUE_STATE and settings.BLUE_API_ACCOUNT):
if info['type'] != 'account':
raise EveApiManager.ApiAccountValidationError(api_id)
if state == MEMBER_STATE:
if int(info['access_mask']) & int(settings.MEMBER_API_MASK) != int(settings.MEMBER_API_MASK):
raise EveApiManager.ApiMaskValidationError(settings.MEMBER_API_MASK, info['access_mask'], api_id)
elif state == BLUE_STATE:
if int(info['access_mask']) & int(settings.BLUE_API_MASK) != int(settings.BLUE_API_MASK):
raise EveApiManager.ApiMaskValidationError(settings.BLUE_API_MASK, info['access_mask'], api_id)
return True

36
services/managers/srp_manager.py
View File

@@ -1,36 +0,0 @@
from __future__ import unicode_literals
from django.conf import settings
import requests
import logging
logger = logging.getLogger(__name__)
class srpManager:
def __init__(self):
pass
@staticmethod
def get_kill_id(killboard_link):
num_set = '0123456789'
kill_id = ''.join([c for c in killboard_link if c in num_set])
return kill_id
@staticmethod
def get_kill_data(kill_id):
url = ("https://www.zkillboard.com/api/killID/%s/" % kill_id)
headers = {
'User-Agent': "%s Alliance Auth" % settings.DOMAIN,
'Content-Type': 'application/json',
}
r = requests.get(url, headers=headers)
result = r.json()[0]
if result:
ship_type = result['victim']['shipTypeID']
logger.debug("Ship type for kill ID %s is determined to be %s" % (kill_id, ship_type))
ship_value = result['zkb']['totalValue']
logger.debug("total loss value for kill id %s is %s" % (kill_id, ship_value))
return ship_type, ship_value
else:
raise ValueError("Invalid Kill ID")

20
services/migrations/0003_auto_20170322_2335.py Normal file
View File

@@ -0,0 +1,20 @@
# -*- coding: utf-8 -*-
# Generated by Django 1.10.5 on 2017-03-22 23:35
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('services', '0002_auto_20161016_0135'),
]
operations = [
migrations.AlterField(
model_name='groupcache',
name='service',
field=models.CharField(choices=[('discourse', 'discourse'), ('discord', 'discord')], max_length=254, unique=True),
),
]

1
services/modules/discord/auth_hooks.py
View File

@@ -2,7 +2,6 @@ from __future__ import unicode_literals
import logging
from django.conf import settings
from django.template.loader import render_to_string
from alliance_auth import hooks

29
services/modules/discord/tasks.py
View File

@@ -7,7 +7,6 @@ from django.conf import settings
from django.contrib.auth.models import User
from django.core.exceptions import ObjectDoesNotExist
from eveonline.managers import EveManager
from notifications import notify
from services.modules.discord.manager import DiscordOAuthManager
from services.tasks import only_one
@@ -60,6 +59,7 @@ class DiscordTasks:
return True
@staticmethod
@only_one
@app.task(bind=True, name='discord.update_groups')
def update_groups(task_self, pk):
user = User.objects.get(pk=pk)
@@ -98,18 +98,21 @@ class DiscordTasks:
user = User.objects.get(pk=pk)
logger.debug("Updating discord nickname for user %s" % user)
if DiscordTasks.has_account(user):
character = EveManager.get_main_character(user)
logger.debug("Updating user %s discord nickname to %s" % (user, character.character_name))
try:
DiscordOAuthManager.update_nickname(user.discord.uid, character.character_name)
except Exception as e:
if self:
logger.exception("Discord nickname sync failed for %s, retrying in 10 mins" % user)
raise self.retry(countdown=60 * 10)
else:
# Rethrow
raise e
logger.debug("Updated user %s discord nickname." % user)
if user.profile.main_character:
character = user.profile.main_character
logger.debug("Updating user %s discord nickname to %s" % (user, character.character_name))
try:
DiscordOAuthManager.update_nickname(user.discord.uid, character.character_name)
except Exception as e:
if self:
logger.exception("Discord nickname sync failed for %s, retrying in 10 mins" % user)
raise self.retry(countdown=60 * 10)
else:
# Rethrow
raise e
logger.debug("Updated user %s discord nickname." % user)
else:
logger.debug("User %s does not have a main character" % user)
else:
logger.debug("User %s does not have a discord account" % user)

2
services/modules/discourse/auth_hooks.py
View File

@@ -46,7 +46,7 @@ class DiscourseService(ServicesHook):
def render_services_ctrl(self, request):
return render_to_string(self.service_ctrl_template, {
'char': EveManager.get_main_character(request.user)
'char': request.user.profile.main_character
}, request=request)

25
services/modules/discourse/views.py
View File

@@ -4,10 +4,6 @@ from django.conf import settings
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.shortcuts import render, redirect
from authentication.states import MEMBER_STATE, BLUE_STATE, NONE_STATE
from eveonline.models import EveCharacter
from eveonline.managers import EveManager
from authentication.models import AuthServicesInfo
from .manager import DiscourseManager
from .tasks import DiscourseTasks
@@ -39,16 +35,15 @@ def discourse_sso(request):
## Check if user has access
auth = AuthServicesInfo.objects.get(user=request.user)
if not request.user.has_perm(ACCESS_PERM):
messages.error(request, 'You are not authorized to access Discourse.')
return redirect('auth_dashboard')
if not auth.main_char_id:
if not request.user.profile.main_character:
messages.error(request, "You must have a main character set to access Discourse.")
return redirect('auth_characters')
main_char = EveManager.get_main_character(request.user)
main_char = request.user.profile.main_character
if main_char is None:
messages.error(request, "Your main character is missing a database model. Please select a new one.")
return redirect('auth_characters')
@@ -60,8 +55,7 @@ def discourse_sso(request):
messages.error(request, 'No SSO payload or signature. Please contact support if this problem persists.')
return redirect('auth_dashboard')
## Validate the payload
# Validate the payload
try:
payload = unquote(payload).encode('utf-8')
decoded = base64.decodestring(payload).decode('utf-8')
@@ -92,24 +86,23 @@ def discourse_sso(request):
'name': username,
}
if auth.main_char_id:
params['avatar_url'] = 'https://image.eveonline.com/Character/%s_256.jpg' % auth.main_char_id
if main_char:
params['avatar_url'] = 'https://image.eveonline.com/Character/%s_256.jpg' % main_char.main_char_id
return_payload = base64.encodestring(urlencode(params).encode('utf-8'))
h = hmac.new(key, return_payload, digestmod=hashlib.sha256)
query_string = urlencode({'sso': return_payload, 'sig': h.hexdigest()})
## Record activation and queue group sync
# Record activation and queue group sync
if not DiscourseTasks.has_account(request.user):
discourse_user = DiscourseUser()
discourse_user.user = request.user
discourse_user.enabled = True
discourse_user.save()
DiscourseTasks.update_groups.apply_async(args=[request.user.pk], countdown=30) # wait 30s for new user creation on Discourse
## Redirect back to Discourse
# wait 30s for new user creation on Discourse before triggering group sync
DiscourseTasks.update_groups.apply_async(args=[request.user.pk], countdown=30)
# Redirect back to Discourse
url = '%s/session/sso_login' % settings.DISCOURSE_URL
return redirect('%s?%s' % (url, query_string))

2
services/modules/ipboard/views.py
View File

@@ -22,7 +22,7 @@ ACCESS_PERM = 'ipboard.access_ipboard'
@permission_required(ACCESS_PERM)
def activate_ipboard_forum(request):
logger.debug("activate_ipboard_forum called by user %s" % request.user)
character = EveManager.get_main_character(request.user)
character = request.user.profile.main_character
logger.debug("Adding ipboard user for user %s with main character %s" % (request.user, character))
result = IPBoardManager.add_user(character.character_name, request.user.email)
if result[0] != "":

4
services/modules/ips4/views.py
View File

@@ -4,8 +4,6 @@ from django.contrib import messages
from django.contrib.auth.decorators import login_required, permission_required
from django.shortcuts import render, redirect
from authentication.decorators import members_and_blues
from eveonline.managers import EveManager
from services.forms import ServicePasswordForm
from .manager import Ips4Manager
@@ -23,7 +21,7 @@ ACCESS_PERM = 'ips4.access_ips4'
@permission_required(ACCESS_PERM)
def activate_ips4(request):
logger.debug("activate_ips4 called by user %s" % request.user)
character = EveManager.get_main_character(request.user)
character = request.user.profile.main_character
logger.debug("Adding IPS4 user for user %s with main character %s" % (request.user, character))
result = Ips4Manager.add_user(character.character_name, request.user.email)
# if empty we failed

2
services/modules/market/views.py
View File

@@ -22,7 +22,7 @@ ACCESS_PERM = 'market.access_market'
@permission_required(ACCESS_PERM)
def activate_market(request):
logger.debug("activate_market called by user %s" % request.user)
character = EveManager.get_main_character(request.user)
character = request.user.profile.main_character
if character is not None:
logger.debug("Adding market user for user %s with main character %s" % (request.user, character))
result = MarketManager.add_user(character.character_name, request.user.email, character.character_id,

20
services/modules/mumble/views.py
View File

@@ -3,16 +3,11 @@ from django.contrib.auth.decorators import login_required, permission_required
from django.shortcuts import render, redirect
from django.contrib import messages
from eveonline.managers import EveManager
from eveonline.models import EveAllianceInfo
from authentication.states import MEMBER_STATE, BLUE_STATE, NONE_STATE
from authentication.models import AuthServicesInfo
from services.forms import ServicePasswordForm
from .manager import MumbleManager
from .tasks import MumbleTasks
from .models import MumbleUser
import logging
@@ -25,20 +20,11 @@ ACCESS_PERM = 'mumble.access_mumble'
@permission_required(ACCESS_PERM)
def activate_mumble(request):
logger.debug("activate_mumble called by user %s" % request.user)
authinfo = AuthServicesInfo.objects.get(user=request.user)
character = EveManager.get_main_character(request.user)
character = request.user.profile.main_character
ticker = character.corporation_ticker
if authinfo.state == BLUE_STATE:
logger.debug("Adding mumble user for blue user %s with main character %s" % (request.user, character))
# Blue members should have alliance ticker (if in alliance)
if EveAllianceInfo.objects.filter(alliance_id=character.alliance_id).exists():
alliance = EveAllianceInfo.objects.filter(alliance_id=character.alliance_id)[0]
ticker = alliance.alliance_ticker
result = MumbleManager.create_user(request.user, ticker, character.character_name, blue=True)
else:
logger.debug("Adding mumble user for user %s with main character %s" % (request.user, character))
result = MumbleManager.create_user(request.user, ticker, character.character_name)
logger.debug("Adding mumble user for %s with main character %s" % (request.user, character))
result = MumbleManager.create_user(request.user, ticker, character.character_name)
if result:
logger.debug("Updated authserviceinfo for user %s with mumble credentials. Updating groups." % request.user)

9
services/modules/openfire/views.py
View File

@@ -4,12 +4,7 @@ from django.contrib import messages
from django.contrib.auth.decorators import login_required, permission_required
from django.contrib.auth.models import Group
from django.shortcuts import render, redirect
from authentication.decorators import members_and_blues
from eveonline.managers import EveManager
from eveonline.models import EveCharacter
from services.forms import ServicePasswordForm
from .manager import OpenfireManager
from .tasks import OpenfireTasks
from .forms import JabberBroadcastForm
@@ -28,7 +23,7 @@ ACCESS_PERM = 'openfire.access_openfire'
@permission_required(ACCESS_PERM)
def activate_jabber(request):
logger.debug("activate_jabber called by user %s" % request.user)
character = EveManager.get_main_character(request.user)
character = request.user.profile.main_character
logger.debug("Adding jabber user for user %s with main character %s" % (request.user, character))
info = OpenfireManager.add_user(character.character_name)
# If our username is blank means we already had a user
@@ -101,7 +96,7 @@ def jabber_broadcast_view(request):
form.fields['group'].choices = allchoices
logger.debug("Received POST request containing form, valid: %s" % form.is_valid())
if form.is_valid():
main_char = EveManager.get_main_character(request.user)
main_char = request.user.profile.main_character
logger.debug("Processing jabber broadcast for user %s with main character %s" % (request.user, main_char))
if main_char is not None:
message_to_send = form.cleaned_data[

2
services/modules/phpbb3/auth_hooks.py
View File

@@ -19,7 +19,7 @@ class Phpbb3Service(ServicesHook):
ServicesHook.__init__(self)
self.name = 'phpbb3'
self.urlpatterns = urlpatterns
self.service_url = settings.FORUM_URL # TODO: This needs to be renamed at some point...
self.service_url = settings.PHPBB3_URL
self.access_perm = 'phpbb3.access_phpbb3'
@property

8
services/modules/phpbb3/views.py
View File

@@ -4,8 +4,6 @@ from django.contrib import messages
from django.contrib.auth.decorators import login_required, permission_required
from django.shortcuts import render, redirect
from authentication.decorators import members_and_blues
from eveonline.managers import EveManager
from services.forms import ServicePasswordForm
from .manager import Phpbb3Manager
@@ -24,7 +22,7 @@ ACCESS_PERM = 'phpbb3.access_phpbb3'
def activate_forum(request):
logger.debug("activate_forum called by user %s" % request.user)
# Valid now we get the main characters
character = EveManager.get_main_character(request.user)
character = request.user.profile.main_character
logger.debug("Adding phpbb user for user %s with main character %s" % (request.user, character))
result = Phpbb3Manager.add_user(character.character_name, request.user.email, ['REGISTERED'],
character.character_id)
@@ -66,7 +64,7 @@ def deactivate_forum(request):
def reset_forum_password(request):
logger.debug("reset_forum_password called by user %s" % request.user)
if Phpbb3Tasks.has_account(request.user):
character = EveManager.get_main_character(request.user)
character = request.user.profile.main_character
result = Phpbb3Manager.update_user_password(request.user.phpbb3.username, character.character_id)
# false we failed
if result != "":
@@ -95,7 +93,7 @@ def set_forum_password(request):
if form.is_valid() and Phpbb3Tasks.has_account(request.user):
password = form.cleaned_data['password']
logger.debug("Form contains password of length %s" % len(password))
character = EveManager.get_main_character(request.user)
character = request.user.profile.main_character
result = Phpbb3Manager.update_user_password(request.user.phpbb3.username, character.character_id,
password=password)
if result != "":

3
services/modules/seat/views.py
View File

@@ -21,8 +21,7 @@ ACCESS_PERM = 'seat.access_seat'
@permission_required(ACCESS_PERM)
def activate_seat(request):
logger.debug("activate_seat called by user %s" % request.user)
# Valid now we get the main characters
character = EveManager.get_main_character(request.user)
character = request.user.profile.main_character
logger.debug("Checking SeAT for inactive users with the same username")
stat = SeatManager.check_user_status(character.character_name)
if stat == {}:

6
services/modules/smf/views.py
View File

@@ -23,7 +23,7 @@ ACCESS_PERM = 'smf.access_smf'
def activate_smf(request):
logger.debug("activate_smf called by user %s" % request.user)
# Valid now we get the main characters
character = EveManager.get_main_character(request.user)
character = request.user.profile.main_character
logger.debug("Adding smf user for user %s with main character %s" % (request.user, character))
result = SmfManager.add_user(character.character_name, request.user.email, ['Member'], character.character_id)
# if empty we failed
@@ -64,7 +64,7 @@ def deactivate_smf(request):
@permission_required(ACCESS_PERM)
def reset_smf_password(request):
logger.debug("reset_smf_password called by user %s" % request.user)
character = EveManager.get_main_character(request.user)
character = request.user.profile.main_character
if SmfTasks.has_account(request.user) and character is not None:
result = SmfManager.update_user_password(request.user.smf.username, character.character_id)
# false we failed
@@ -90,7 +90,7 @@ def set_smf_password(request):
logger.debug("Received POST request with form.")
form = ServicePasswordForm(request.POST)
logger.debug("Form is valid: %s" % form.is_valid())
character = EveManager.get_main_character(request.user)
character = request.user.profile.main_character
if form.is_valid() and SmfTasks.has_account(request.user) and character is not None:
password = form.cleaned_data['password']
logger.debug("Form contains password of length %s" % len(password))

33
services/modules/teamspeak3/manager.py
View File

@@ -33,11 +33,6 @@ class Teamspeak3Manager:
sanatized = "[" + corp_ticker + "]" + username
return sanatized[:30]
@staticmethod
def __generate_username_blue(username, corp_ticker):
sanatized = "[BLUE][" + corp_ticker + "]" + username
return sanatized[:30]
@staticmethod
def _get_userid(uid):
logger.debug("Looking for uid %s on TS3 server." % uid)
@@ -210,34 +205,6 @@ class Teamspeak3Manager:
logger.exception("Failed to add teamspeak user %s - received response: %s" % (username_clean, ret))
return "", ""
@staticmethod
def add_blue_user(username, corp_ticker):
username_clean = Teamspeak3Manager.__santatize_username(Teamspeak3Manager.__generate_username_blue(username,
corp_ticker))
server = Teamspeak3Manager.__get_created_server()
logger.debug("Adding user to TS3 server with cleaned username %s" % username_clean)
server_groups = Teamspeak3Manager._group_list()
if settings.DEFAULT_BLUE_GROUP not in server_groups:
Teamspeak3Manager._create_group(settings.DEFAULT_BLUE_GROUP)
blue_group_id = Teamspeak3Manager._group_id_by_name(settings.DEFAULT_BLUE_GROUP)
try:
ret = server.send_command('tokenadd', {'tokentype': 0, 'tokenid1': blue_group_id, 'tokenid2': 0,
'tokendescription': username_clean,
'tokencustomset': "ident=sso_uid value=%s" % username_clean})
except TeamspeakError as e:
logger.error("Failed to add blue teamspeak user %s: %s" % (username, str(e)))
return "",""
try:
token = ret['keys']['token']
logger.info("Created permission token for blue user %s on TS3 server" % username_clean)
return username_clean, token
except:
logger.exception("Failed to add blue teamspeak user %s - received response: %s" % (username_clean, ret))
return "", ""
@staticmethod
def delete_user(uid):
server = Teamspeak3Manager.__get_created_server()

3
services/modules/teamspeak3/tasks.py
View File

@@ -3,13 +3,10 @@ from __future__ import unicode_literals
import logging
from alliance_auth.celeryapp import app
from celery.schedules import crontab
from django.conf import settings
from django.contrib.auth.models import User
from django.core.exceptions import ObjectDoesNotExist
from notifications import notify
from authentication.models import AuthServicesInfo
from .util.ts3 import TeamspeakError
from .manager import Teamspeak3Manager
from .models import AuthTS, TSgroup, UserTSgroup, Teamspeak3User

34
services/modules/teamspeak3/views.py
View File

@@ -4,11 +4,6 @@ from django.contrib import messages
from django.contrib.auth.decorators import login_required, permission_required
from django.shortcuts import render, redirect
from authentication.states import BLUE_STATE
from authentication.models import AuthServicesInfo
from eveonline.managers import EveManager
from eveonline.models import EveAllianceInfo
from services.modules.teamspeak3.manager import Teamspeak3Manager
from .forms import TeamspeakJoinForm
@@ -25,20 +20,11 @@ ACCESS_PERM = 'teamspeak3.access_teamspeak3'
def activate_teamspeak3(request):
logger.debug("activate_teamspeak3 called by user %s" % request.user)
authinfo = AuthServicesInfo.objects.get(user=request.user)
character = EveManager.get_main_character(request.user)
character = request.user.profile.main_character
ticker = character.corporation_ticker
if authinfo.state == BLUE_STATE:
logger.debug("Adding TS3 user for blue user %s with main character %s" % (request.user, character))
# Blue members should have alliance ticker (if in alliance)
if EveAllianceInfo.objects.filter(alliance_id=character.alliance_id).exists():
alliance = EveAllianceInfo.objects.filter(alliance_id=character.alliance_id)[0]
ticker = alliance.alliance_ticker
result = Teamspeak3Manager.add_blue_user(character.character_name, ticker)
else:
logger.debug("Adding TS3 user for user %s with main character %s" % (request.user, character))
result = Teamspeak3Manager.add_user(character.character_name, ticker)
logger.debug("Adding TS3 user for user %s with main character %s" % (request.user, character))
result = Teamspeak3Manager.add_user(character.character_name, ticker)
# if its empty we failed
if result[0] is not "":
@@ -93,20 +79,12 @@ def reset_teamspeak3_perm(request):
logger.debug("reset_teamspeak3_perm called by user %s" % request.user)
if not Teamspeak3Tasks.has_account(request.user):
return redirect("auth_services")
authinfo = AuthServicesInfo.objects.get(user=request.user)
character = EveManager.get_main_character(request.user)
character = request.user.profile.main_character
logger.debug("Deleting TS3 user for user %s" % request.user)
Teamspeak3Manager.delete_user(request.user.teamspeak3.uid)
if authinfo.state == BLUE_STATE:
logger.debug(
"Generating new permission key for blue user %s with main character %s" % (request.user, character))
result = Teamspeak3Manager.generate_new_blue_permissionkey(request.user.teamspeak3.uid,
character.character_name,
character.corporation_ticker)
else:
logger.debug("Generating new permission key for user %s with main character %s" % (request.user, character))
result = Teamspeak3Manager.generate_new_permissionkey(request.user.teamspeak3.uid, character.character_name,
logger.debug("Generating new permission key for user %s with main character %s" % (request.user, character))
result = Teamspeak3Manager.generate_new_permissionkey(request.user.teamspeak3.uid, character.character_name,
character.corporation_ticker)
# if blank we failed

2
services/modules/xenforo/views.py
View File

@@ -21,7 +21,7 @@ ACCESS_PERM = 'xenforo.access_xenforo'
@permission_required(ACCESS_PERM)
def activate_xenforo_forum(request):
logger.debug("activate_xenforo_forum called by user %s" % request.user)
character = EveManager.get_main_character(request.user)
character = request.user.profile.main_character
logger.debug("Adding XenForo user for user %s with main character %s" % (request.user, character))
result = XenForoManager.add_user(character.character_name, request.user.email)
# Based on XenAPI's response codes

8
services/signals.py
View File

@@ -10,10 +10,7 @@ from django.db.models.signals import pre_save
from django.dispatch import receiver
from services.hooks import ServicesHook
from alliance_auth.hooks import get_hooks
from authentication.tasks import disable_user
from authentication.tasks import disable_member
from authentication.tasks import set_state
from services.tasks import disable_user
logger = logging.getLogger(__name__)
@@ -109,8 +106,5 @@ def pre_save_user(sender, instance, *args, **kwargs):
if old_instance.is_active and not instance.is_active:
logger.info("Disabling services for inactivation of user %s" % instance)
disable_user(instance)
elif instance.is_active and not old_instance.is_active:
logger.info("Assessing state of reactivated user %s" % instance)
set_state(instance)
except User.DoesNotExist:
pass

8
services/tasks.py
View File

@@ -48,3 +48,11 @@ def validate_services(self, user):
svc.validate_user(user)
except:
logger.exception('Exception running validate_user for services module %s on user %s' % (svc, user))
def disable_user(user):
logger.debug('Disabling all services for user %s' % user)
for svc in ServicesHook.get_services():
if svc.service_active_for_user(user):
svc.delete_user(user)

13
services/views.py
View File

@@ -6,8 +6,6 @@ from django.shortcuts import render
from django.utils.translation import ugettext_lazy as _
from alliance_auth.hooks import get_hooks
from authentication.decorators import members_and_blues
from authentication.models import AuthServicesInfo
from eveonline.models import EveCharacter
from services.forms import FleetFormatterForm
@@ -49,19 +47,12 @@ def fleet_formatter_view(request):
@login_required
def services_view(request):
logger.debug("services_view called by user %s" % request.user)
auth = AuthServicesInfo.objects.get(user=request.user)
char = None
if auth.main_char_id:
try:
char = EveCharacter.objects.get(character_id=auth.main_char_id)
except EveCharacter.DoesNotExist:
messages.warning(request, _("There's a problem with your main character. Please select a new one."))
char = request.profile.main_character
context = {'service_ctrls': []}
for fn in get_hooks('services_hook'):
# Render hooked services controls
svc = fn()
if svc.show_service_ctrl(request.user, auth.state):
if svc.show_service_ctrl(request.user):
context['service_ctrls'].append(svc.render_services_ctrl(request))
return render(request, 'registered/services.html', context=context)