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

The Great Services Refactor (#594)

Browse Source 
* Hooks registration, discovery and retrieval module

Will discover @hooks.register decorated functions inside
the auth_hooks module in any installed django app.

* Class to register modular service apps

* Register service modules URLs

* Example service module

* Refactor services into modules

Each service type has been split out into its own django app/module. A
hook mechanism is provided to register a subclass of the ServiceHook
class. The modules then overload functions defined in ServiceHook as
required to provide interoperability with alliance auth. Service modules
provide their own urls and views for user registration and account
management and a partial template to display on the services page. Where
possible, new modules should provide their own models for local data
storage.

* Added menu items hooks and template tags

* Added menu item hook for broadcasts

* Added str method to ServicesHook

* Added exception handling to hook iterators

* Refactor mumble migration and table name

Upgrading will require `migrate mumble --fake-initial` to be run first
and then `migrate mumble` to rename the table.

* Refactor teamspeak3 migration and rename table

Upgrading will require `migrate teamspeak3 --fake-initial`

* Added module models and migrations for refactoring AuthServicesInfo

* Migrate AuthServiceInfo fields to service modules models

* Added helper for getting a users main character

* Added new style celery instance

* Changed Discord from AuthServicesInfo to DiscordUser model

* Switch celery tasks to staticmethods

* Changed Discourse from AuthServicesInfo to DiscourseUser model

* Changed IPBoard from AuthServicesInfo to IpboardUser model

* Changed Ips4 from AuthServicesInfo to Ips4User model

Also added disable service task.

This service still needs some love though. Was always missing a
deactivate services hook (before refactoring) for reasons I'm unsure of
so I'm reluctant to add it without knowing why.

* Changed Market from AuthServicesInfo to MarketUser model

* Changed Mumble from AuthServicesInfo to MumbleUser model

Switched user foreign key to one to one relationship.
Removed implicit password change on user exists.
Combined regular and blue user creation.

* Changed Openfire from AuthServicesInfo to OpenfireUser model

* Changed SMF from AuthServicesInfo to SmfUser model

Added disable task

* Changed Phpbb3 from AuthServicesInfo to Phpbb3User model

* Changed XenForo from AuthServicesInfo to XenforoUser model

* Changed Teamspeak3 from AuthServicesInfo to Teamspeak3User model

* Remove obsolete manager functions

* Standardise URL format

This will break some callback URLs
Discord changes from /discord_callback/ to /discord/callback/

* Removed unnecessary imports

* Mirror upstream decorator change

* Setup for unit testing

* Unit tests for discord service

* Added add main character helper

* Added Discourse unit tests

* Added Ipboard unit tests

* Added Ips4 unit tests

* Fix naming of market manager, switch to use class methods

* Remove unused hook functions

* Added market service unit tests

* Added corp ticker to add main character helper

* Added mumble unit tests

* Fix url name and remove namespace

* Fix missing return and add missing URL

* Added openfire unit tests

* Added missing return

* Added phpbb3 unit tests

* Fix SmfManager naming inconsistency and switch to classmethods

* Added smf unit tests

* Remove unused functions, Added missing return

* Added xenforo unit tests

* Added missing return

* Fixed reference to old model

* Fixed error preventing groups from syncing on reset request

* Added teamspeak3 unit tests

* Added nose as test runner and some test settings

* Added package requirements for running tests

* Added unit tests for services signals and tasks

* Remove unused tests file

* Fix teamspeak3 service signals

* Added unit tests for teamspeak3 signals

Changed other unit tests setUp to inert signals

* Fix password gen and hashing python3 compatibility

Fixes #630

Adds unit tests to check the password functions run on both platforms.

* Fix unit test to not rely on checking url params

* Add Travis CI settings file

* Remove default blank values from services models

* Added dynamic user model admin actions for syncing service groups

* Remove unused search fields

* Add hook function for syncing nicknames

* Added discord hook for sync nickname

* Added user admin model menu actions for sync nickname hook

* Remove obsolete code

* Rename celery config app to avoid package name clash

* Added new style celerybeat schedule configuration

periodic_task decorator is depreciated

* Added string representations

* Added admin pages for services user models

* Removed legacy code

* Move link discord button to correct template

* Remove blank default fields from example model

* Disallow empty django setting

* Fix typos

* Added coverage configuration file

* Add coverage and coveralls to travis config

Should probably use nose's built in coverage, but this works for now.

* Replace AuthServicesInfo get_or_create instances with get

Reflects upstream changes to AuthServicesInfo behaviour.

* Update mumble user table name

* Split out mumble authenticator requirements

zeroc-ice seems to cause long build times on travis-ci and isn't
required for the core projects functionality or testing.
This commit is contained in:
Basraah
2017-01-25 12:50:16 +10:00
committed by GitHub
parent 5738b015c3
commit 1066e6ac98
195 changed files with 8260 additions and 2699 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
services/modules/teamspeak3/__init__.py Normal file
View File

17
services/modules/teamspeak3/admin.py Normal file
View File

@@ -0,0 +1,17 @@
from __future__ import unicode_literals
from django.contrib import admin
from .models import AuthTS, Teamspeak3User
class Teamspeak3UserAdmin(admin.ModelAdmin):
list_display = ('user', 'uid', 'perm_key')
search_fields = ('user__username', 'uid', 'perm_key')
class AuthTSgroupAdmin(admin.ModelAdmin):
fields = ['auth_group', 'ts_group']
filter_horizontal = ('ts_group',)
admin.site.register(AuthTS, AuthTSgroupAdmin)
admin.site.register(Teamspeak3User, Teamspeak3UserAdmin)

10
services/modules/teamspeak3/apps.py Normal file
View File

@@ -0,0 +1,10 @@
from __future__ import unicode_literals
from django.apps import AppConfig
class Teamspeak3ServiceConfig(AppConfig):
name = 'teamspeak3'
def ready(self):
from . import signals

61
services/modules/teamspeak3/auth_hooks.py Normal file
View File

@@ -0,0 +1,61 @@
from __future__ import unicode_literals
from django.conf import settings
from django.template.loader import render_to_string
from services.hooks import ServicesHook
from alliance_auth import hooks
from .urls import urlpatterns
from .tasks import Teamspeak3Tasks
import logging
logger = logging.getLogger(__name__)
class Teamspeak3Service(ServicesHook):
def __init__(self):
ServicesHook.__init__(self)
self.name = 'teamspeak3'
self.urlpatterns = urlpatterns
self.service_ctrl_template = 'registered/teamspeak3_service_ctrl.html'
def delete_user(self, user, notify_user=False):
logger.debug('Deleting user %s %s account' % (user, self.name))
return Teamspeak3Tasks.delete_user(user, notify_user=notify_user)
def update_groups(self, user):
logger.debug('Updating %s groups for %s' % (self.name, user))
Teamspeak3Tasks.update_groups.delay(user.pk)
def validate_user(self, user):
logger.debug('Validating user %s %s account' % (user, self.name))
if Teamspeak3Tasks.has_account(user) and not self.service_active_for_user(user):
self.delete_user(user, notify_user=True)
def update_all_groups(self):
logger.debug('Update all %s groups called' % self.name)
Teamspeak3Tasks.update_all_groups.delay()
def service_enabled_members(self):
return settings.ENABLE_AUTH_TEAMSPEAK3 or False
def service_enabled_blues(self):
return settings.ENABLE_BLUE_TEAMSPEAK3 or False
def render_services_ctrl(self, request):
authinfo = {'teamspeak3_uid': '',
'teamspeak3_perm_key': '',}
if Teamspeak3Tasks.has_account(request.user):
authinfo['teamspeak3_uid'] = request.user.teamspeak3.uid
authinfo['teamspeak3_perm_key'] = request.user.teamspeak3.perm_key
return render_to_string(self.service_ctrl_template, {
'authinfo': authinfo,
}, request=request)
@hooks.register('services_hook')
def register_service():
return Teamspeak3Service()

15
services/modules/teamspeak3/forms.py Normal file
View File

@@ -0,0 +1,15 @@
from __future__ import unicode_literals
from django import forms
from django.utils.translation import ugettext_lazy as _
from .manager import Teamspeak3Manager
class TeamspeakJoinForm(forms.Form):
username = forms.CharField(widget=forms.HiddenInput())
def clean(self):
if Teamspeak3Manager._get_userid(self.cleaned_data['username']):
return self.cleaned_data
raise forms.ValidationError(_("Unable to locate user %s on server") % self.cleaned_data['username'])

316
services/modules/teamspeak3/manager.py Executable file
View File

@@ -0,0 +1,316 @@
from __future__ import unicode_literals
import logging
from django.conf import settings
from services.modules.teamspeak3.util.ts3 import TS3Server, TeamspeakError
from .models import TSgroup
logger = logging.getLogger(__name__)
class Teamspeak3Manager:
def __init__(self):
pass
@staticmethod
def __get_created_server():
server = TS3Server(settings.TEAMSPEAK3_SERVER_IP, settings.TEAMSPEAK3_SERVER_PORT)
server.login(settings.TEAMSPEAK3_SERVERQUERY_USER, settings.TEAMSPEAK3_SERVERQUERY_PASSWORD)
server.use(settings.TEAMSPEAK3_VIRTUAL_SERVER)
logger.debug("Got TS3 server instance based on settings.")
return server
@staticmethod
def __santatize_username(username):
sanatized = username.replace(" ", "_")
sanatized = sanatized.replace("'", "-")
return sanatized
@staticmethod
def __generate_username(username, corp_ticker):
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)
server = Teamspeak3Manager.__get_created_server()
try:
ret = server.send_command('customsearch', {'ident': 'sso_uid', 'pattern': uid})
if ret and 'keys' in ret and 'cldbid' in ret['keys']:
logger.debug("Got userid %s for uid %s" % (ret['keys']['cldbid'], uid))
return ret['keys']['cldbid']
except TeamspeakError as e:
if not e.code == '1281':
raise e
return None
@staticmethod
def _group_id_by_name(groupname):
server = Teamspeak3Manager.__get_created_server()
logger.debug("Looking for group %s on TS3 server." % groupname)
group_cache = server.send_command('servergrouplist')
logger.debug("Received group cache from server: %s" % group_cache)
for group in group_cache:
logger.debug("Checking group %s" % group)
if group['keys']['name'] == groupname:
logger.debug("Found group %s, returning id %s" % (groupname, group['keys']['sgid']))
return group['keys']['sgid']
logger.debug("Group %s not found on server." % groupname)
return None
@staticmethod
def _create_group(groupname):
logger.debug("Creating group %s on TS3 server." % groupname)
server = Teamspeak3Manager.__get_created_server()
sgid = Teamspeak3Manager._group_id_by_name(groupname)
if not sgid:
logger.debug("Group does not yet exist. Proceeding with creation.")
ret = server.send_command('servergroupadd', {'name': groupname})
Teamspeak3Manager.__group_cache = None
sgid = ret['keys']['sgid']
server.send_command('servergroupaddperm',
{'sgid': sgid, 'permsid': 'i_group_needed_modify_power', 'permvalue': 75,
'permnegated': 0, 'permskip': 0})
server.send_command('servergroupaddperm',
{'sgid': sgid, 'permsid': 'i_group_needed_member_add_power', 'permvalue': 100,
'permnegated': 0, 'permskip': 0})
server.send_command('servergroupaddperm',
{'sgid': sgid, 'permsid': 'i_group_needed_member_remove_power', 'permvalue': 100,
'permnegated': 0, 'permskip': 0})
logger.info("Created group on TS3 server with name %s and id %s" % (groupname, sgid))
return sgid
@staticmethod
def _user_group_list(cldbid):
logger.debug("Retrieving group list for user with id %s" % cldbid)
server = Teamspeak3Manager.__get_created_server()
try:
groups = server.send_command('servergroupsbyclientid', {'cldbid': cldbid})
except TeamspeakError as e:
if e.code == '1281': # no groups
groups = []
else:
raise e
logger.debug("Retrieved group list: %s" % groups)
outlist = {}
if type(groups) == list:
logger.debug("Recieved multiple groups. Iterating.")
for group in groups:
outlist[group['keys']['name']] = group['keys']['sgid']
elif type(groups) == dict:
logger.debug("Recieved single group.")
outlist[groups['keys']['name']] = groups['keys']['sgid']
logger.debug("Returning name/id pairing: %s" % outlist)
return outlist
@staticmethod
def _group_list():
logger.debug("Retrieving group list on TS3 server.")
server = Teamspeak3Manager.__get_created_server()
group_cache = server.send_command('servergrouplist')
logger.debug("Received group cache from server: %s" % group_cache)
outlist = {}
if group_cache:
for group in group_cache:
logger.debug("Assigning name/id dict: %s = %s" % (group['keys']['name'], group['keys']['sgid']))
outlist[group['keys']['name']] = group['keys']['sgid']
else:
logger.error("Received empty group cache while retrieving group cache from TS3 server. 1024 error.")
logger.debug("Returning name/id pairing: %s" % outlist)
return outlist
@staticmethod
def _add_user_to_group(uid, groupid):
logger.debug("Adding group id %s to TS3 user id %s" % (groupid, uid))
server = Teamspeak3Manager.__get_created_server()
user_groups = Teamspeak3Manager._user_group_list(uid)
if groupid not in user_groups.values():
logger.debug("User does not have group already. Issuing command to add.")
server.send_command('servergroupaddclient',
{'sgid': str(groupid), 'cldbid': uid})
logger.info("Added user id %s to group id %s on TS3 server." % (uid, groupid))
@staticmethod
def _remove_user_from_group(uid, groupid):
logger.debug("Removing group id %s from TS3 user id %s" % (groupid, uid))
server = Teamspeak3Manager.__get_created_server()
user_groups = Teamspeak3Manager._user_group_list(uid)
if str(groupid) in user_groups.values():
logger.debug("User is in group. Issuing command to remove.")
server.send_command('servergroupdelclient',
{'sgid': str(groupid), 'cldbid': uid})
logger.info("Removed user id %s from group id %s on TS3 server." % (uid, groupid))
@staticmethod
def _sync_ts_group_db():
logger.debug("_sync_ts_group_db function called.")
try:
remote_groups = Teamspeak3Manager._group_list()
local_groups = TSgroup.objects.all()
logger.debug("Comparing remote groups to TSgroup objects: %s" % local_groups)
for key in remote_groups:
logger.debug("Typecasting remote_group value at position %s to int: %s" % (key, remote_groups[key]))
remote_groups[key] = int(remote_groups[key])
for group in local_groups:
logger.debug("Checking local group %s" % group)
if group.ts_group_id not in remote_groups.values():
logger.debug(
"Local group id %s not found on server. Deleting model %s" % (group.ts_group_id, group))
TSgroup.objects.filter(ts_group_id=group.ts_group_id).delete()
for key in remote_groups:
g = TSgroup(ts_group_id=remote_groups[key], ts_group_name=key)
q = TSgroup.objects.filter(ts_group_id=g.ts_group_id)
if not q:
logger.debug("Local group does not exist for TS group %s. Creating TSgroup model %s" % (
remote_groups[key], g))
g.save()
except TeamspeakError as e:
logger.error("Error occured while syncing TS group db: %s" % str(e))
except:
logger.exception("An unhandled exception has occured while syncing TS groups.")
@staticmethod
def add_user(username, corp_ticker):
username_clean = Teamspeak3Manager.__santatize_username(Teamspeak3Manager.__generate_username(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_AUTH_GROUP not in server_groups:
Teamspeak3Manager._create_group(settings.DEFAULT_AUTH_GROUP)
alliance_group_id = Teamspeak3Manager._group_id_by_name(settings.DEFAULT_AUTH_GROUP)
try:
ret = server.send_command('tokenadd', {'tokentype': 0, 'tokenid1': alliance_group_id, 'tokenid2': 0,
'tokendescription': username_clean,
'tokencustomset': "ident=sso_uid value=%s" % username_clean})
except TeamspeakError as e:
logger.error("Failed to add teamspeak user %s: %s" % (username, str(e)))
return "",""
try:
token = ret['keys']['token']
logger.info("Created permission token for user %s on TS3 server" % username_clean)
return username_clean, token
except:
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()
user = Teamspeak3Manager._get_userid(uid)
logger.debug("Deleting user %s with id %s from TS3 server." % (user, uid))
if user:
clients = server.send_command('clientlist')
for client in clients:
try:
if client['keys']['client_database_id'] == user:
logger.debug("Found user %s on TS3 server - issuing deletion command." % user)
server.send_command('clientkick', {'clid': client['keys']['clid'], 'reasonid': 5,
'reasonmsg': 'Auth service deleted'})
except:
logger.exception("Failed to delete user id %s from TS3 - received response %s" % (uid, client))
return False
try:
ret = server.send_command('clientdbdelete', {'cldbid': user})
except TeamspeakError as e:
logger.error("Failed to delete teamspeak user %s: %s" % (uid, str(e)))
return False
if ret == '0':
logger.info("Deleted user with id %s from TS3 server." % uid)
return True
else:
logger.exception("Failed to delete user id %s from TS3 - received response %s" % (uid, ret))
return False
else:
logger.warn("User with id %s not found on TS3 server. Assuming succesful deletion." % uid)
return True
@staticmethod
def check_user_exists(uid):
if Teamspeak3Manager._get_userid(uid):
return True
return False
@staticmethod
def generate_new_permissionkey(uid, username, corpticker):
logger.debug("Re-issuing permission key for user id %s" % uid)
Teamspeak3Manager.delete_user(uid)
return Teamspeak3Manager.add_user(username, corpticker)
@staticmethod
def generate_new_blue_permissionkey(uid, username, corpticker):
logger.debug("Re-issuing blue permission key for user id %s" % uid)
Teamspeak3Manager.delete_user(uid)
return Teamspeak3Manager.add_blue_user(username, corpticker)
@staticmethod
def update_groups(uid, ts_groups):
logger.debug("Updating uid %s TS3 groups %s" % (uid, ts_groups))
userid = Teamspeak3Manager._get_userid(uid)
addgroups = []
remgroups = []
if userid is not None:
user_ts_groups = Teamspeak3Manager._user_group_list(userid)
logger.debug("User has groups on TS3 server: %s" % user_ts_groups)
for key in user_ts_groups:
user_ts_groups[key] = int(user_ts_groups[key])
for ts_group_key in ts_groups:
logger.debug("Checking if user has group %s on TS3 server." % ts_group_key)
if ts_groups[ts_group_key] not in user_ts_groups.values():
addgroups.append(ts_groups[ts_group_key])
for user_ts_group_key in user_ts_groups:
if user_ts_groups[user_ts_group_key] not in ts_groups.values():
remgroups.append(user_ts_groups[user_ts_group_key])
for g in addgroups:
logger.info("Adding Teamspeak user %s into group %s" % (userid, g))
Teamspeak3Manager._add_user_to_group(userid, g)
for g in remgroups:
logger.info("Removing Teamspeak user %s from group %s" % (userid, g))
Teamspeak3Manager._remove_user_from_group(userid, g)

59
services/modules/teamspeak3/migrations/0001_initial.py Normal file
View File

@@ -0,0 +1,59 @@
# -*- coding: utf-8 -*-
# Generated by Django 1.10.2 on 2016-12-12 01:11
from __future__ import unicode_literals
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
('auth', '0008_alter_user_username_max_length'),
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='AuthTS',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('auth_group', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='auth.Group')),
],
options={
'db_table': 'services_authts',
'verbose_name': 'Auth / TS Group',
},
),
migrations.CreateModel(
name='TSgroup',
fields=[
('ts_group_id', models.IntegerField(primary_key=True, serialize=False)),
('ts_group_name', models.CharField(max_length=30)),
],
options={
'db_table': 'services_tsgroup',
'verbose_name': 'TS Group',
},
),
migrations.CreateModel(
name='UserTSgroup',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('ts_group', models.ManyToManyField(to='teamspeak3.TSgroup')),
('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
],
options={
'db_table': 'services_usertsgroup',
'verbose_name': 'User TS Group',
},
),
migrations.AddField(
model_name='authts',
name='ts_group',
field=models.ManyToManyField(to='teamspeak3.TSgroup'),
),
]

27
services/modules/teamspeak3/migrations/0002_auto_20161212_0133.py Normal file
View File

@@ -0,0 +1,27 @@
# -*- coding: utf-8 -*-
# Generated by Django 1.10.2 on 2016-12-12 01:33
from __future__ import unicode_literals
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('teamspeak3', '0001_initial'),
]
operations = [
migrations.AlterModelTable(
name='authts',
table=None,
),
migrations.AlterModelTable(
name='tsgroup',
table=None,
),
migrations.AlterModelTable(
name='usertsgroup',
table=None,
),
]

26
services/modules/teamspeak3/migrations/0003_teamspeak3user.py Normal file
View File

@@ -0,0 +1,26 @@
# -*- coding: utf-8 -*-
# Generated by Django 1.10.2 on 2016-12-12 03:14
from __future__ import unicode_literals
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('auth', '0008_alter_user_username_max_length'),
('teamspeak3', '0002_auto_20161212_0133'),
]
operations = [
migrations.CreateModel(
name='Teamspeak3User',
fields=[
('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, primary_key=True, related_name='teamspeak3', serialize=False, to=settings.AUTH_USER_MODEL)),
('uid', models.CharField(max_length=254)),
('perm_key', models.CharField(max_length=254)),
],
),
]

0
services/modules/teamspeak3/migrations/__init__.py Normal file
View File

52
services/modules/teamspeak3/models.py Normal file
View File

@@ -0,0 +1,52 @@
from __future__ import unicode_literals
from django.utils.encoding import python_2_unicode_compatible
from django.db import models
@python_2_unicode_compatible
class Teamspeak3User(models.Model):
user = models.OneToOneField('auth.User',
primary_key=True,
on_delete=models.CASCADE,
related_name='teamspeak3')
uid = models.CharField(max_length=254)
perm_key = models.CharField(max_length=254)
def __str__(self):
return self.uid
@python_2_unicode_compatible
class TSgroup(models.Model):
ts_group_id = models.IntegerField(primary_key=True)
ts_group_name = models.CharField(max_length=30)
class Meta:
verbose_name = 'TS Group'
def __str__(self):
return self.ts_group_name
@python_2_unicode_compatible
class AuthTS(models.Model):
auth_group = models.ForeignKey('auth.Group')
ts_group = models.ManyToManyField(TSgroup)
class Meta:
verbose_name = 'Auth / TS Group'
def __str__(self):
return self.auth_group.name
@python_2_unicode_compatible
class UserTSgroup(models.Model):
user = models.ForeignKey('auth.User')
ts_group = models.ManyToManyField(TSgroup)
class Meta:
verbose_name = 'User TS Group'
def __str__(self):
return self.user.name

38
services/modules/teamspeak3/signals.py Normal file
View File

@@ -0,0 +1,38 @@
from __future__ import unicode_literals
import logging
from django.db import transaction
from django.db.models.signals import m2m_changed
from django.db.models.signals import post_delete
from django.db.models.signals import post_save
from django.dispatch import receiver
from .tasks import Teamspeak3Tasks
from .models import AuthTS
logger = logging.getLogger(__name__)
def trigger_all_ts_update():
logger.debug("Triggering update_all_groups")
Teamspeak3Tasks.update_all_groups()
@receiver(m2m_changed, sender=AuthTS.ts_group.through)
def m2m_changed_authts_group(sender, instance, action, *args, **kwargs):
logger.debug("Received m2m_changed from %s ts_group with action %s" % (instance, action))
if action == "post_add" or action == "post_remove":
transaction.on_commit(trigger_all_ts_update)
@receiver(post_save, sender=AuthTS)
def post_save_authts(sender, instance, *args, **kwargs):
logger.debug("Received post_save from %s" % instance)
transaction.on_commit(trigger_all_ts_update)
@receiver(post_delete, sender=AuthTS)
def post_delete_authts(sender, instance, *args, **kwargs):
logger.debug("Received post_delete signal from %s" % instance)
transaction.on_commit(trigger_all_ts_update)

96
services/modules/teamspeak3/tasks.py Normal file
View File

@@ -0,0 +1,96 @@
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
logger = logging.getLogger(__name__)
class Teamspeak3Tasks:
def __init__(self):
pass
@classmethod
def delete_user(cls, user, notify_user=False):
if cls.has_account(user):
logger.debug("User %s has TS3 account %s. Deleting." % (user, user.teamspeak3.uid))
if Teamspeak3Manager.delete_user(user.teamspeak3.uid):
user.teamspeak3.delete()
if notify_user:
notify(user, 'TeamSpeak3 Account Disabled', level='danger')
return True
return False
@staticmethod
def has_account(user):
try:
return user.teamspeak3.uid != ''
except ObjectDoesNotExist:
return False
@staticmethod
@app.task()
def run_ts3_group_update():
if settings.ENABLE_AUTH_TEAMSPEAK3 or settings.ENABLE_BLUE_TEAMSPEAK3:
logger.debug("TS3 installed. Syncing local group objects.")
Teamspeak3Manager._sync_ts_group_db()
@staticmethod
def disable():
if settings.ENABLE_AUTH_TEAMSPEAK3:
logger.warn(
"ENABLE_AUTH_TEAMSPEAK3 still True, after disabling users will still be able to create teamspeak accounts")
if settings.ENABLE_BLUE_TEAMSPEAK3:
logger.warn(
"ENABLE_BLUE_TEAMSPEAK3 still True, after disabling blues will still be able to create teamspeak accounts")
logger.info("Deleting all Teamspeak3Users")
Teamspeak3User.objects.all().delete()
logger.info("Deleting all UserTSgroup models")
UserTSgroup.objects.all().delete()
logger.info("Deleting all AuthTS models")
AuthTS.objects.all().delete()
logger.info("Deleting all TSgroup models")
TSgroup.objects.all().delete()
logger.info("Teamspeak3 disabled")
@staticmethod
@app.task(bind=True)
def update_groups(self, pk):
user = User.objects.get(pk=pk)
logger.debug("Updating user %s teamspeak3 groups" % user)
if Teamspeak3Tasks.has_account(user):
usergroups = user.groups.all()
groups = {}
for usergroup in usergroups:
filtered_groups = AuthTS.objects.filter(auth_group=usergroup)
if filtered_groups:
for filtered_group in filtered_groups:
for ts_group in filtered_group.ts_group.all():
groups[ts_group.ts_group_name] = ts_group.ts_group_id
logger.debug("Updating user %s teamspeak3 groups to %s" % (user, groups))
try:
Teamspeak3Manager.update_groups(user.teamspeak3.uid, groups)
logger.debug("Updated user %s teamspeak3 groups." % user)
except TeamspeakError as e:
logger.error("Error occured while syncing TS groups for %s: %s" % (user, str(e)))
raise self.retry(countdown=60*10)
else:
logger.debug("User does not have a teamspeak3 account")
@staticmethod
@app.task
def update_all_groups():
logger.debug("Updating ALL teamspeak3 groups")
for user in Teamspeak3User.objects.exclude(uid__exact=''):
Teamspeak3Tasks.update_groups.delay(user.user_id)

34
services/modules/teamspeak3/templates/registered/teamspeak3_service_ctrl.html Normal file
View File

@@ -0,0 +1,34 @@
{% load i18n %}
<tr>
<th class="text-center">{% trans "Service" %}</th>
<th class="text-center">{% trans "Unique ID" %}</th>
<th class="text-center">PermissionKey</th>
<th class="text-center">{% trans "Action" %}</th>
</tr>
<tr>
<td class="text-center">Teamspeak 3</td>
<td class="text-center">{{ authinfo.teamspeak3_uid }}</td>
<td class="text-center">{{ authinfo.teamspeak3_perm_key }}</td>
<td class="text-center">
{% ifequal authinfo.teamspeak3_uid "" %}
<a href="{% url 'auth_activate_teamspeak3' %}" class="btn btn-warning">
<span class="glyphicon glyphicon-ok"></span>
</a>
{% else %}
<a href="ts3server://{{ TEAMSPEAK3_PUBLIC_URL }}?token={{ authinfo.teamspeak3_perm_key }}&nickname={{ authinfo.teamspeak3_uid }}"
title="{% trans "Quick Link" %}" class="btn btn-info">
<span class="glyphicon glyphicon-link"></span>
</a>
<a href="{% url 'auth_verify_teamspeak3' %}" class="btn btn-success" title="Verify">
<span class="glyphicon glyphicon-log-in"></span>
</a>
<a href="{% url 'auth_reset_teamspeak3_perm' %}" class="btn btn-primary">
<span class="glyphicon glyphicon-refresh"></span>
</a>
<a href="{% url 'auth_deactivate_teamspeak3' %}" class="btn btn-danger">
<span class="glyphicon glyphicon-remove"></span>
</a>
{% endifequal %}
</td>
</tr>

328
services/modules/teamspeak3/tests.py Normal file
View File

@@ -0,0 +1,328 @@
from __future__ import unicode_literals
try:
# Py3
from unittest import mock
except ImportError:
# Py2
import mock
from django.test import TestCase, RequestFactory
from django.conf import settings
from django import urls
from django.contrib.auth.models import User, Group
from django.core.exceptions import ObjectDoesNotExist
from django.db.models import signals
from alliance_auth.tests.auth_utils import AuthUtils
from .auth_hooks import Teamspeak3Service
from .models import Teamspeak3User, AuthTS, TSgroup
from .tasks import Teamspeak3Tasks
from .signals import m2m_changed_authts_group, post_save_authts, post_delete_authts
MODULE_PATH = 'services.modules.teamspeak3'
class Teamspeak3HooksTestCase(TestCase):
def setUp(self):
# Inert signals before setup begins
with mock.patch(MODULE_PATH + '.signals.trigger_all_ts_update') as trigger_all_ts_update:
self.member = 'member_user'
member = AuthUtils.create_member(self.member)
Teamspeak3User.objects.create(user=member, uid=self.member, perm_key='123ABC')
self.blue = 'blue_user'
blue = AuthUtils.create_blue(self.blue)
Teamspeak3User.objects.create(user=blue, uid=self.blue, perm_key='456DEF')
self.none_user = 'none_user'
none_user = AuthUtils.create_user(self.none_user)
ts_member_group = TSgroup.objects.create(ts_group_id=1, ts_group_name='Member')
ts_blue_group = TSgroup.objects.create(ts_group_id=2, ts_group_name='Blue')
m2m_member_group = AuthTS.objects.create(auth_group=member.groups.all()[0])
m2m_member_group.ts_group.add(ts_member_group)
m2m_member_group.save()
m2m_blue_group = AuthTS.objects.create(auth_group=blue.groups.all()[0])
m2m_blue_group.ts_group.add(ts_blue_group)
m2m_blue_group.save()
self.service = Teamspeak3Service
def test_has_account(self):
member = User.objects.get(username=self.member)
blue = User.objects.get(username=self.blue)
none_user = User.objects.get(username=self.none_user)
self.assertTrue(Teamspeak3Tasks.has_account(member))
self.assertTrue(Teamspeak3Tasks.has_account(blue))
self.assertFalse(Teamspeak3Tasks.has_account(none_user))
def test_service_enabled(self):
service = self.service()
member = User.objects.get(username=self.member)
blue = User.objects.get(username=self.blue)
none_user = User.objects.get(username=self.none_user)
self.assertTrue(service.service_enabled_members())
self.assertTrue(service.service_enabled_blues())
self.assertEqual(service.service_active_for_user(member), settings.ENABLE_AUTH_TEAMSPEAK3)
self.assertEqual(service.service_active_for_user(blue), settings.ENABLE_BLUE_TEAMSPEAK3)
self.assertFalse(service.service_active_for_user(none_user))
@mock.patch(MODULE_PATH + '.tasks.Teamspeak3Manager')
def test_update_all_groups(self, manager):
service = self.service()
service.update_all_groups()
# Check member and blue user have groups updated
self.assertTrue(manager.update_groups.called)
self.assertEqual(manager.update_groups.call_count, 2)
def test_update_groups(self):
# Check member has Member group updated
with mock.patch(MODULE_PATH + '.tasks.Teamspeak3Manager') as manager:
service = self.service()
member = User.objects.get(username=self.member)
service.update_groups(member)
self.assertTrue(manager.update_groups.called)
args, kwargs = manager.update_groups.call_args
# update_groups(user.teamspeak3.uid, groups)
self.assertEqual({'Member': 1}, args[1]) # Check groups
self.assertEqual(self.member, args[0]) # Check uid
# Check none user does not have groups updated
with mock.patch(MODULE_PATH + '.tasks.Teamspeak3Manager') as manager:
service = self.service()
none_user = User.objects.get(username=self.none_user)
service.update_groups(none_user)
self.assertFalse(manager.update_user_groups.called)
@mock.patch(MODULE_PATH + '.tasks.Teamspeak3Manager')
def test_validate_user(self, manager):
service = self.service()
# Test member is not deleted
member = User.objects.get(username=self.member)
service.validate_user(member)
self.assertTrue(member.teamspeak3)
# Test none user is deleted
none_user = User.objects.get(username=self.none_user)
Teamspeak3User.objects.create(user=none_user, uid='abc123', perm_key='132ACB')
service.validate_user(none_user)
self.assertTrue(manager.delete_user.called)
with self.assertRaises(ObjectDoesNotExist):
none_teamspeak3 = User.objects.get(username=self.none_user).teamspeak3
@mock.patch(MODULE_PATH + '.tasks.Teamspeak3Manager')
def test_delete_user(self, manager):
member = User.objects.get(username=self.member)
service = self.service()
result = service.delete_user(member)
self.assertTrue(result)
self.assertTrue(manager.delete_user.called)
with self.assertRaises(ObjectDoesNotExist):
teamspeak3_user = User.objects.get(username=self.member).teamspeak3
def test_render_services_ctrl(self):
service = self.service()
member = User.objects.get(username=self.member)
request = RequestFactory().get('/en/services/')
request.user = member
response = service.render_services_ctrl(request)
self.assertTemplateUsed(service.service_ctrl_template)
self.assertIn(urls.reverse('auth_deactivate_teamspeak3'), response)
self.assertIn(urls.reverse('auth_reset_teamspeak3_perm'), response)
# Test register becomes available
member.teamspeak3.delete()
member = User.objects.get(username=self.member)
request.user = member
response = service.render_services_ctrl(request)
self.assertIn(urls.reverse('auth_activate_teamspeak3'), response)
class Teamspeak3ViewsTestCase(TestCase):
def setUp(self):
# Inert signals before setup begins
with mock.patch(MODULE_PATH + '.signals.trigger_all_ts_update') as trigger_all_ts_update:
self.member = AuthUtils.create_member('auth_member')
self.member.set_password('password')
self.member.email = 'auth_member@example.com'
self.member.save()
AuthUtils.add_main_character(self.member, 'auth_member', '12345', corp_id='111', corp_name='Test Corporation')
self.blue_user = AuthUtils.create_blue('auth_blue')
self.blue_user.set_password('password')
self.blue_user.email = 'auth_blue@example.com'
self.blue_user.save()
AuthUtils.add_main_character(self.blue_user, 'auth_blue', '92345', corp_id='111', corp_name='Test Corporation')
ts_member_group = TSgroup.objects.create(ts_group_id=1, ts_group_name='Member')
ts_blue_group = TSgroup.objects.create(ts_group_id=2, ts_group_name='Blue')
m2m_member = AuthTS.objects.create(auth_group=Group.objects.get(name='Member'))
m2m_member.ts_group.add(ts_member_group)
m2m_member.save()
m2m_blue = AuthTS.objects.create(auth_group=Group.objects.get(name='Blue'))
m2m_blue.ts_group.add(ts_blue_group)
m2m_blue.save()
def login(self, user=None, password=None):
if user is None:
user = self.member
self.client.login(username=user.username, password=password if password else 'password')
@mock.patch(MODULE_PATH + '.forms.Teamspeak3Manager')
@mock.patch(MODULE_PATH + '.views.Teamspeak3Manager')
def test_activate(self, manager, forms_manager):
self.login()
expected_username = 'auth_member'
manager.add_user.return_value = (expected_username, 'abc123')
response = self.client.get(urls.reverse('auth_activate_teamspeak3'))
self.assertTrue(manager.add_user.called)
teamspeak3_user = Teamspeak3User.objects.get(user=self.member)
self.assertTrue(teamspeak3_user.uid)
self.assertTrue(teamspeak3_user.perm_key)
self.assertRedirects(response, urls.reverse('auth_verify_teamspeak3'), target_status_code=200)
@mock.patch(MODULE_PATH + '.forms.Teamspeak3Manager')
@mock.patch(MODULE_PATH + '.views.Teamspeak3Manager')
def test_activate_blue(self, manager, forms_manager):
self.login(self.blue_user)
expected_username = 'auth_blue'
manager.add_blue_user.return_value = (expected_username, 'abc123')
response = self.client.get(urls.reverse('auth_activate_teamspeak3'))
self.assertTrue(manager.add_blue_user.called)
teamspeak3_user = Teamspeak3User.objects.get(user=self.blue_user)
self.assertTrue(teamspeak3_user.uid)
self.assertTrue(teamspeak3_user.perm_key)
self.assertRedirects(response, urls.reverse('auth_verify_teamspeak3'), target_status_code=200)
@mock.patch(MODULE_PATH + '.forms.Teamspeak3Manager')
@mock.patch(MODULE_PATH + '.tasks.Teamspeak3Manager')
def test_verify_submit(self, manager, forms_manager):
self.login()
expected_username = 'auth_member'
forms_manager._get_userid.return_value = '1234'
Teamspeak3User.objects.update_or_create(user=self.member, defaults={'uid': '1234', 'perm_key': '5678'})
data = {'username': 'auth_member'}
response = self.client.post(urls.reverse('auth_verify_teamspeak3'), data)
self.assertTrue(manager.update_groups.called)
self.assertRedirects(response, urls.reverse('auth_services'), target_status_code=200)
@mock.patch(MODULE_PATH + '.tasks.Teamspeak3Manager')
def test_deactivate(self, manager):
self.login()
Teamspeak3User.objects.create(user=self.member, uid='some member')
response = self.client.get(urls.reverse('auth_deactivate_teamspeak3'))
self.assertTrue(manager.delete_user.called)
self.assertRedirects(response, expected_url=urls.reverse('auth_services'), target_status_code=200)
with self.assertRaises(ObjectDoesNotExist):
teamspeak3_user = User.objects.get(pk=self.member.pk).teamspeak3
@mock.patch(MODULE_PATH + '.tasks.Teamspeak3Manager')
@mock.patch(MODULE_PATH + '.views.Teamspeak3Manager')
def test_reset_perm(self, manager, tasks_manager):
self.login()
Teamspeak3User.objects.create(user=self.member, uid='some member')
manager.generate_new_permissionkey.return_value = "valid_member", "123abc"
response = self.client.get(urls.reverse('auth_reset_teamspeak3_perm'))
self.assertRedirects(response, urls.reverse('auth_services'), target_status_code=200)
ts3_user = Teamspeak3User.objects.get(uid='valid_member')
self.assertEqual(ts3_user.uid, 'valid_member')
self.assertEqual(ts3_user.perm_key, '123abc')
self.assertTrue(tasks_manager.update_groups.called)
@mock.patch(MODULE_PATH + '.tasks.Teamspeak3Manager')
@mock.patch(MODULE_PATH + '.views.Teamspeak3Manager')
def test_reset_perm_blue(self, manager, tasks_manager):
self.login(self.blue_user)
Teamspeak3User.objects.create(user=self.blue_user, uid='some member')
manager.generate_new_blue_permissionkey.return_value = "valid_blue", "123abc"
response = self.client.get(urls.reverse('auth_reset_teamspeak3_perm'))
self.assertRedirects(response, urls.reverse('auth_services'), target_status_code=200)
ts3_user = Teamspeak3User.objects.get(uid='valid_blue')
self.assertEqual(ts3_user.uid, 'valid_blue')
self.assertEqual(ts3_user.perm_key, '123abc')
self.assertTrue(tasks_manager.update_groups.called)
class Teamspeak3SignalsTestCase(TestCase):
def setUp(self):
self.member = AuthUtils.create_member('auth_member')
# Suppress signals action while setting up
with mock.patch(MODULE_PATH + '.signals.trigger_all_ts_update') as trigger_all_ts_update:
ts_member_group = TSgroup.objects.create(ts_group_id=1, ts_group_name='Member')
self.m2m_member = AuthTS.objects.create(auth_group=Group.objects.get(name='Member'))
self.m2m_member.ts_group.add(ts_member_group)
self.m2m_member.save()
def test_m2m_signal_registry(self):
"""
Test that the m2m signal has been registered
"""
registered_functions = [r[1]() for r in signals.m2m_changed.receivers]
self.assertIn(m2m_changed_authts_group, registered_functions)
def test_post_save_signal_registry(self):
"""
Test that the post_save signal has been registered
"""
registered_functions = [r[1]() for r in signals.post_save.receivers]
self.assertIn(post_save_authts, registered_functions)
def test_post_delete_signal_registry(self):
"""
Test that the post_delete signal has been registered
"""
registered_functions = [r[1]() for r in signals.post_delete.receivers]
self.assertIn(post_delete_authts, registered_functions)
@mock.patch(MODULE_PATH + '.signals.transaction')
@mock.patch(MODULE_PATH + '.signals.trigger_all_ts_update')
def test_m2m_changed_authts_group(self, trigger_all_ts_update, transaction):
# Overload transaction.on_commit so everything happens synchronously
transaction.on_commit = lambda fn: fn()
new_group = TSgroup.objects.create(ts_group_id=99, ts_group_name='new TS group')
self.m2m_member.ts_group.add(new_group)
self.m2m_member.save() # Triggers signal
self.assertTrue(trigger_all_ts_update.called)
@mock.patch(MODULE_PATH + '.signals.transaction')
@mock.patch(MODULE_PATH + '.signals.trigger_all_ts_update')
def test_post_save_authts(self, trigger_all_ts_update, transaction):
# Overload transaction.on_commit so everything happens synchronously
transaction.on_commit = lambda fn: fn()
AuthTS.objects.create(auth_group=Group.objects.create(name='Test Group')) # Trigger signal (AuthTS creation)
self.assertTrue(trigger_all_ts_update.called)
@mock.patch(MODULE_PATH + '.signals.transaction')
@mock.patch(MODULE_PATH + '.signals.trigger_all_ts_update')
def test_post_delete_authts(self, trigger_all_ts_update, transaction):
# Overload transaction.on_commit so everything happens synchronously
transaction.on_commit = lambda fn: fn()
self.m2m_member.delete() # Trigger delete signal
self.assertTrue(trigger_all_ts_update.called)

21
services/modules/teamspeak3/urls.py Normal file
View File

@@ -0,0 +1,21 @@
from __future__ import unicode_literals
from django.conf.urls import url, include
from . import views
module_urls = [
# Teamspeak3 service control
url(r'^activate/$', views.activate_teamspeak3,
name='auth_activate_teamspeak3'),
url(r'^deactivate/$', views.deactivate_teamspeak3,
name='auth_deactivate_teamspeak3'),
url(r'reset_perm/$', views.reset_teamspeak3_perm,
name='auth_reset_teamspeak3_perm'),
# Teamspeak Urls
url(r'verify/$', views.verify_teamspeak3, name='auth_verify_teamspeak3'),
]
urlpatterns = [
url(r'^teamspeak3/', include(module_urls)),
]

2
services/modules/teamspeak3/util/__init__.py Executable file
View File

@@ -0,0 +1,2 @@
from __future__ import unicode_literals
__author__ = 'r4stl1n'

459
services/modules/teamspeak3/util/ts3.py Executable file
View File

@@ -0,0 +1,459 @@
from __future__ import unicode_literals
import socket
import logging
class ConnectionError:
def __init__(self, ip, port):
self.ip = ip
self.port = port
def __str__(self):
return 'Error connecting to host %s port %s' % (self.ip, self.port)
ts3_escape = {'/': r"\/",
' ': r'\s',
'|': r'\p',
"\a": r'\a',
"\b": r'\b',
"\f": r'\f',
"\n": r'\n',
"\r": r'\r',
"\t": r'\t',
"\v": r'\v'}
class TS3Proto:
bytesin = 0
bytesout = 0
_connected = False
def __init__(self):
self._log = logging.getLogger('%s.%s' % (__name__, self.__class__.__name__))
pass
def connect(self, ip, port):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
s.connect((ip, port))
except:
# raise ConnectionError(ip, port)
raise
else:
self._sock = s
self._sockfile = s.makefile('r', 0)
data = self._sockfile.readline()
if data.strip() == "TS3":
self._sockfile.readline()
self._connected = True
return True
def disconnect(self):
self.send_command("quit")
self._sock.close()
self._sock = None
self._connected = False
self._log.info('Disconnected')
def send_command(self, command, keys=None, opts=None):
cmd = self.construct_command(command, keys=keys, opts=opts)
self.send('%s\n' % cmd)
data = []
while True:
resp = self._sockfile.readline()
resp = self.parse_command(resp)
if 'command' not in resp:
data.append(resp)
else:
break
if resp['command'] == 'error':
if resp['keys']['id'] == '0':
if data:
if len(data) > 1:
return data
else:
return data[0]
else:
return resp['keys']['id']
else:
raise TeamspeakError(resp['keys']['id'])
def construct_command(self, command, keys=None, opts=None):
"""
Constructs a TS3 formatted command string
Keys can have a single nested list to construct a nested parameter
@param command: Command list
@type command: string
@param keys: Key/Value pairs
@type keys: dict
@param opts: Options
@type opts: list
"""
cstr = [command]
# Add the keys and values, escape as needed
if keys:
for key in keys:
if isinstance(keys[key], list):
ncstr = []
for nest in keys[key]:
ncstr.append("%s=%s" % (key, self._escape_str(nest)))
cstr.append("|".join(ncstr))
else:
cstr.append("%s=%s" % (key, self._escape_str(keys[key])))
# Add in options
if opts:
for opt in opts:
cstr.append("-%s" % opt)
return " ".join(cstr)
def parse_command(self, commandstr):
"""
Parses a TS3 command string into command/keys/opts tuple
@param commandstr: Command string
@type commandstr: string
"""
if len(commandstr.split('|')) > 1:
vals = []
for cmd in commandstr.split('|'):
vals.append(self.parse_command(cmd))
return vals
cmdlist = commandstr.strip().split(' ')
command = None
keys = {}
opts = []
for key in cmdlist:
v = key.strip().split('=')
if len(v) > 1:
# Key
if len > 2:
# Fix the stupidities in TS3 escaping
v = [v[0], '='.join(v[1:])]
key, value = v
keys[key] = self._unescape_str(value)
elif not v == ['']:
if v[0][0] and v[0][0] == '-':
# Option
opts.append(v[0][1:])
else:
command = v[0]
d = {'keys': keys, 'opts': opts}
if command:
d['command'] = command
return d
@staticmethod
def _escape_str(value):
"""
Escape a value into a TS3 compatible string
@param value: Value
@type value: string/int
"""
if isinstance(value, int):
return "%d" % value
value = value.replace("\\", r'\\')
for i, j in ts3_escape.items():
value = value.replace(i, j)
return value
@staticmethod
def _unescape_str(value):
"""
Unescape a TS3 compatible string into a normal string
@param value: Value
@type value: string/int
"""
if isinstance(value, int):
return "%d" % value
value = value.replace(r"\\", "\\")
for i, j in ts3_escape.items():
value = value.replace(j, i)
return value
def send(self, payload):
if self._connected:
self._log.debug('Sent: %s' % payload)
self._sockfile.write(payload)
class TS3Server(TS3Proto):
def __init__(self, ip, port, id=0, sock=None):
"""
Abstraction class for TS3 Servers
@param ip: IP Address
@type ip: str
@param port: Port Number
@type port: int
"""
TS3Proto.__init__(self)
if not sock:
if self.connect(ip, port) and id > 0:
self.use(id)
else:
self._sock = sock
self._sockfile = sock.makefile('r', 0)
self._connected = True
def login(self, username, password):
"""
Login to the TS3 Server
@param username: Username
@type username: str
@param password: Password
@type password: str
"""
d = self.send_command('login', keys={'client_login_name': username, 'client_login_password': password})
if d == 0:
self._log.info('Login Successful')
return True
return False
def serverlist(self):
"""
Get a list of all Virtual Servers on the connected TS3 instance
"""
if self._connected:
return self.send_command('serverlist')
def gm(self, msg):
"""
Send a global message to the current Virtual Server
@param msg: Message
@type msg: str
"""
if self._connected:
return self.send_command('gm', keys={'msg': msg})
def use(self, id):
"""
Use a particular Virtual Server instance
@param id: Virtual Server ID
@type id: int
"""
if self._connected and id > 0:
self.send_command('use', keys={'sid': id})
class TeamspeakError(Exception):
def __init__(self, code, msg=None):
self.code = str(code)
if not msg:
msg = ts3_errors[self.code]
self.msg = msg
def __str__(self):
return self.code + ' ' + self.msg
ts3_errors = {
'0': 'unknown error code',
'1': 'undefined error',
'2': 'not implemented',
'3': '',
'4': '',
'5': 'library time limit reached',
'256': 'command not found',
'257': 'unable to bind network port',
'258': 'no network port available',
'512': 'invalid clientID',
'513': 'nickname is already in use',
'514': 'invalid error code',
'515': 'max clients protocol limit reached',
'516': 'invalid client type',
'517': 'already subscribed',
'518': 'not logged in',
'519': 'could not validate client identity',
'520': 'invalid loginname or password',
'521': 'too many clones already connected',
'522': 'client version outdated, please update',
'523': 'client is online',
'524': 'client is flooding',
'525': 'client is modified',
'526': 'can not verify client at this moment',
'527': 'client is not permitted to log in',
'528': 'client is not subscribed to the channel',
'768': 'invalid channelID',
'769': 'max channels protocol limit reached',
'770': 'already member of channel',
'771': 'channel name is already in use',
'772': 'channel not empty',
'773': 'can not delete default channel',
'774': 'default channel requires permanent',
'775': 'invalid channel flags',
'776': 'permanent channel can not be child of non permanent channel',
'777': 'channel maxclient reached',
'778': 'channel maxfamily reached',
'779': 'invalid channel order',
'780': 'channel does not support filetransfers',
'781': 'invalid channel password',
'782': 'channel is private channel',
'783': 'invalid security hash supplied by client',
'1024': 'invalid serverID',
'1025': 'server is running',
'1026': 'server is shutting down',
'1027': 'server maxclient reached',
'1028': 'invalid server password',
'1029': 'deployment active',
'1030': 'unable to stop own server in your connection class',
'1031': 'server is virtual',
'1032': 'server wrong machineID',
'1033': 'server is not running',
'1034': 'server is booting up',
'1035': 'server got an invalid status for this operation',
'1036': 'server modal quit',
'1037': 'server version is too old for command',
'1280': 'database error',
'1281': 'database empty result set',
'1282': 'database duplicate entry',
'1283': 'database no modifications',
'1284': 'database invalid constraint',
'1285': 'database reinvoke command',
'1536': 'invalid quote',
'1537': 'invalid parameter count',
'1538': 'invalid parameter',
'1539': 'parameter not found',
'1540': 'convert error',
'1541': 'invalid parameter size',
'1542': 'missing required parameter',
'1543': 'invalid checksum',
'1792': 'virtual server got a critical error',
'1793': 'Connection lost',
'1794': 'not connected',
'1795': 'no cached connection info',
'1796': 'currently not possible',
'1797': 'failed connection initialization',
'1798': 'could not resolve hostname',
'1799': 'invalid server connection handler ID',
'1800': 'could not initialize Input Manager',
'1801': 'client library not initialized',
'1802': 'server library not initialized',
'1803': 'too many whisper targets',
'1804': 'no whisper targets found',
'2048': 'invalid file name',
'2049': 'invalid file permissions',
'2050': 'file already exists',
'2051': 'file not found',
'2052': 'file input/output error',
'2053': 'invalid file transfer ID',
'2054': 'invalid file path',
'2055': 'no files available',
'2056': 'overwrite excludes resume',
'2057': 'invalid file size',
'2058': 'file already in use',
'2059': 'could not open file transfer connection',
'2060': 'no space left on device (disk full?)',
'2061': "file exceeds file system's maximum file size",
'2062': 'file transfer connection timeout',
'2063': 'lost file transfer connection',
'2064': 'file exceeds supplied file size',
'2065': 'file transfer complete',
'2066': 'file transfer canceled',
'2067': 'file transfer interrupted',
'2068': 'file transfer server quota exceeded',
'2069': 'file transfer client quota exceeded',
'2070': 'file transfer reset',
'2071': 'file transfer limit reached',
'2304': 'preprocessor disabled',
'2305': 'internal preprocessor',
'2306': 'internal encoder',
'2307': 'internal playback',
'2308': 'no capture device available',
'2309': 'no playback device available',
'2310': 'could not open capture device',
'2311': 'could not open playback device',
'2312': 'ServerConnectionHandler has a device registered',
'2313': 'invalid capture device',
'2314': 'invalid clayback device',
'2315': 'invalid wave file',
'2316': 'wave file type not supported',
'2317': 'could not open wave file',
'2318': 'internal capture',
'2319': 'device still in use',
'2320': 'device already registerred',
'2321': 'device not registered/known',
'2322': 'unsupported frequency',
'2323': 'invalid channel count',
'2324': 'read error in wave',
'2325': 'sound need more data',
'2326': 'sound device was busy',
'2327': 'there is no sound data for this period',
'2328': 'Channelmask set bits count (speakers) is not the same as channel (count)',
'2560': 'invalid group ID',
'2561': 'duplicate entry',
'2562': 'invalid permission ID',
'2563': 'empty result set',
'2564': 'access to default group is forbidden',
'2565': 'invalid size',
'2566': 'invalid value',
'2567': 'group is not empty',
'2568': 'insufficient client permissions',
'2569': 'insufficient group modify power',
'2570': 'insufficient permission modify power',
'2571': 'template group is currently used',
'2572': 'permission error',
'2816': 'virtualserver limit reached',
'2817': 'max slot limit reached',
'2818': 'license file not found',
'2819': 'license date not ok',
'2820': 'unable to connect to accounting server',
'2821': 'unknown accounting error',
'2822': 'accounting server error',
'2823': 'instance limit reached',
'2824': 'instance check error',
'2825': 'license file invalid',
'2826': 'virtualserver is running elsewhere',
'2827': 'virtualserver running in same instance already',
'2828': 'virtualserver already started',
'2829': 'virtualserver not started',
'2830': '',
'3072': 'invalid message id',
'3328': 'invalid ban id',
'3329': 'connection failed, you are banned',
'3330': 'rename failed, new name is banned',
'3331': 'flood ban',
'3584': 'unable to initialize tts',
'3840': 'invalid privilege key',
'4096': '',
'4097': '',
'4098': '',
'4099': '',
'4100': '',
'4101': '',
'4102': '',
'4103': '',
'4352': 'invalid password',
'4353': 'invalid request',
'4354': 'no (more) slots available',
'4355': 'pool missing',
'4356': 'pool unknown',
'4357': 'unknown ip location (perhaps LAN ip?)',
'4358': 'internal error (tried exceeded)',
'4359': 'too many slots requested',
'4360': 'too many reserved',
'4361': 'could not connect to provisioning server',
'4368': 'authentication server not connected',
'4369': 'authentication data too large',
'4370': 'already initialized',
'4371': 'not initialized',
'4372': 'already connecting',
'4373': 'already connected',
'4374': '',
'4375': 'io_error',
'4376': '',
'4377': '',
'4378': '',
}

121
services/modules/teamspeak3/views.py Normal file
View File

@@ -0,0 +1,121 @@
import logging
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.shortcuts import render, redirect
from authentication.decorators import members_and_blues
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
from .tasks import Teamspeak3Tasks
from .models import Teamspeak3User
logger = logging.getLogger(__name__)
@login_required
@members_and_blues()
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)
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)
# if its empty we failed
if result[0] is not "":
Teamspeak3User.objects.update_or_create(user=request.user, defaults={'uid': result[0], 'perm_key': result[1]})
logger.debug("Updated authserviceinfo for user %s with TS3 credentials. Updating groups." % request.user)
logger.info("Successfully activated TS3 for user %s" % request.user)
messages.success(request, 'Activated TeamSpeak3 account.')
return redirect("auth_verify_teamspeak3")
logger.error("Unsuccessful attempt to activate TS3 for user %s" % request.user)
messages.error(request, 'An error occurred while processing your TeamSpeak3 account.')
return redirect("auth_services")
@login_required
@members_and_blues()
def verify_teamspeak3(request):
logger.debug("verify_teamspeak3 called by user %s" % request.user)
if not Teamspeak3Tasks.has_account(request.user):
logger.warn("Unable to validate user %s teamspeak: no teamspeak data" % request.user)
return redirect("auth_services")
if request.method == "POST":
form = TeamspeakJoinForm(request.POST)
if form.is_valid():
Teamspeak3Tasks.update_groups.delay(request.user.pk)
logger.debug("Validated user %s joined TS server" % request.user)
return redirect("auth_services")
else:
form = TeamspeakJoinForm({'username': request.user.teamspeak3.uid})
context = {
'form': form,
'authinfo': {'teamspeak3_uid': request.user.teamspeak3.uid,
'teamspeak3_perm_key': request.user.teamspeak3.perm_key},
}
return render(request, 'registered/teamspeakjoin.html', context=context)
@login_required
@members_and_blues()
def deactivate_teamspeak3(request):
logger.debug("deactivate_teamspeak3 called by user %s" % request.user)
if Teamspeak3Tasks.has_account(request.user) and Teamspeak3Tasks.delete_user(request.user):
logger.info("Successfully deactivated TS3 for user %s" % request.user)
messages.success(request, 'Deactivated TeamSpeak3 account.')
logger.error("Unsuccessful attempt to deactivate TS3 for user %s" % request.user)
messages.error(request, 'An error occurred while processing your TeamSpeak3 account.')
return redirect("auth_services")
@login_required
@members_and_blues()
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)
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,
character.corporation_ticker)
# if blank we failed
if result[0] != "":
Teamspeak3User.objects.update_or_create(user=request.user, defaults={'uid': result[0], 'perm_key': result[1]})
logger.debug("Updated authserviceinfo for user %s with TS3 credentials. Updating groups." % request.user)
Teamspeak3Tasks.update_groups.delay(request.user.pk)
logger.info("Successfully reset TS3 permission key for user %s" % request.user)
messages.success(request, 'Reset TeamSpeak3 permission key.')
else:
logger.error("Unsuccessful attempt to reset TS3 permission key for user %s" % request.user)
messages.error(request, 'An error occurred while processing your TeamSpeak3 account.')
return redirect("auth_services")