Synnefo

        return user.get_auth_provider().get_automoderate_policy

import copy

import json

from synnefo.lib.ordereddict import OrderedDict

from django.contrib.auth.models import Group

from django import template

            if newcls().get_required_policy:

    message_tpls = OrderedDict((

        ('title', '{module_title}'),

        ('login_title', '{title} LOGIN'),

        ('method_prompt', '{title} login'),

        ('account_prompt', '{title} account'),

        ('signup_title', '{title}'),

        ('profile_title', '{title}'),

        ('method_details', '{account_prompt}: {identifier}'),

        ('primary_login_prompt', 'Login using '),

        ('required', '{title} is required. You can assign it '

                     'from your profile page'),

        ('login_prompt', ''),

        ('add_prompt', 'Allows you to login using {title}'),

        ('login_extra', ''),

        ('username', '{username}'),

        ('disabled_for_create', '{title} is not available for signup.'),

        ('switch_success', 'Account changed successfully.'),

        ('cannot_login', '{title} is not available for login. '

                         'Please use one of your other available methods '

                         'to login ({available_methods_links}'),

        # icons should end with _icon

        ('module_medium_icon', 'im/auth/icons-medium/{module}.png'),

        ('module_icon', 'im/auth/icons/{module}.png'))

    )

    messages = {}

    module_urls = {}

    # templates

    primary_login_template = 'im/auth/generic_primary_login.html'

    login_template = 'im/auth/generic_login.html'

    signup_template = 'im/signup.html'

    login_prompt_template = 'im/auth/generic_login_prompt.html'

    signup_prompt_template = 'im/auth/signup_prompt.html'

    default_policies = {

        'login': True,

        'create': True,

        'add': True,

        'remove': True,

        'limit': 1,

        'switch': True,

        'add_groups': [],

        'creation_groups': [],

        'required': False,

        'automoderate': not astakos_settings.MODERATION_ENABLED

    }

    policies = {}

    def __init__(self, user=None, identifier=None, **provider_params):

        """

        3 ways to initialize (no args, user, user and identifier).

        no args: Used for anonymous unauthenticated users.

        >>> p = auth_providers.get_provider('local')

        >>> # check that global settings allows us to create a new account

        >>> # using `local` provider.

        >>> print p.is_available_for_create()

        user and identifier: Used to provide details about a user's specific

        login method.

        >>> p = auth_providers.get_provider('google', identifier='1421421')

        >>> # provider (google) details prompt

        >>> print p.get_method_details()

        "Google account: 1421421"

        """

        # handle AnonymousUser instance

        self.user = None

        if user and hasattr(user, 'pk') and user.pk:

            self.user = user

        self.identifier = identifier

        self._instance = None

        if 'instance' in provider_params:

            self._instance = provider_params['instance']

            del provider_params['instance']

        # initialize policies

        self.module_policies = copy.copy(self.default_policies)

        self.module_policies['automoderate'] = not \

            astakos_settings.MODERATION_ENABLED

        for policy, value in self.policies.keys():

            setting_key = "%s_POLICY" % policy.upper()

            if self.has_setting(setting_key):

                self.module_policies[policy] = self.get_setting(setting_key)

        # messages cache

        self.message_tpls_compiled = OrderedDict()

        # module specific messages

        self.message_tpls = OrderedDict(self.message_tpls)

        for key, value in self.messages.iteritems():

            self.message_tpls[key] = value

        self._provider_details = provider_params

        self.resolve_available_methods = True

    def get_provider_model(self):

        from astakos.im.models import AstakosUserAuthProvider as AuthProvider

        return AuthProvider

    def remove_from_user(self):

        if not self.get_remove_policy:

            raise Exception("Provider cannot be removed")

        self._instance.delete()

    def add_to_user(self, **params):

        if self._instance:

            raise Exception("Cannot add an existing provider")

        create = False

        if self.get_user_providers().count() == 0:

            create = True

        if create and not self.get_create_policy:

            raise Exception("Provider not available for create")

        if not self.get_add_policy:

            raise Exception("Provider cannot be added")

        if create:

            for group_name in self.get_creation_groups_policy:

                group, created = Group.objects.get_or_create(name=group_name)

                self.user.groups.add(group)

        for group_name in self.get_add_groups_policy:

            group, created = Group.objects.get_or_create(name=group_name)

            self.user.groups.add(group)

        if self.identifier:

            pending = self.get_provider_model().objects.unverified(

                self.module, identifier=self.identifier)

            if pending:

                pending._instance.delete()

        create_params = {

            'module': self.module,

            'info_data': json.dumps(self.provider_details.get('info', {})),

            'active': True,

            'identifier': self.identifier

        }

        if 'info' in self.provider_details:

            del self.provider_details['info']

        create_params.update(self.provider_details)

        create_params.update(params)

        return self.user.auth_providers.create(**create_params)

    def __repr__(self):

        r = "'%s' module" % self.__class__.__name__

        if self.user:

            r += ' (user: %s)' % self.user

        if self.identifier:

            r += ' (identifier: %s)' % self.identifier

        return r

    def _message_params(self, **extra_params):

        """

        Retrieve message formating parameters.

        """

        params = {'module': self.module, 'module_title': self.module.title()}

        if self.identifier:

            params['identifier'] = self.identifier

        if self.user:

            for key, val in self.user.__dict__.iteritems():

                params["user_%s" % key.lower()] = val

        if self.provider_details:

            for key, val in self.provider_details.iteritems():

                params["provider_%s" % key.lower()] = val

            if 'info' in self.provider_details:

                if isinstance(self.provider_details['info'], basestring):

                    self.provider_details['info'] = \

                        json.loads(self.provider_details['info'])

                for key, val in self.provider_details['info'].iteritems():

                   params['provider_info_%s' % key.lower()] = val

        # resolve username, handle unexisting defined username key

        if self.user and self.username_key in params:

            params['username'] = params[self.username_key]

        else:

            params['username'] = self.identifier

        if not self.message_tpls_compiled:

            for key, message_tpl in self.message_tpls.iteritems():

                msg = self.messages.get(key, self.message_tpls.get(key))

                override_in_settings = self.get_setting(key)

                if override_in_settings is not None:

                    msg = override_in_settings

                try:

                    self.message_tpls_compiled[key] = msg.format(**params)

                    params.update(self.message_tpls_compiled)

                except KeyError, e:

                    continue

        else:

            params.update(self.message_tpls_compiled)

        for key, value in self.urls.iteritems():

            params['%s_url' % key] = value

        if self.user and self.resolve_available_methods:

            available_providers = self.user.get_enabled_auth_providers()

            for p in available_providers:

                p.resolve_available_methods = False

                if p.module == self.module and p.identifier == self.identifier:

                    available_providers.remove(p)

            get_msg = lambda p: p.get_method_prompt_msg

            params['available_methods'] = \

                ','.join(map(get_msg, available_providers))

            get_msg = lambda p: "<a href='%s'>%s</a>" % \

                (p.get_method_prompt_msg, p.get_login_url)

            params['available_methods_links'] = \

                ','.join(map(get_msg, available_providers))

        params.update(extra_params)

        return params

    def get_template(self, tpl):

        tpls = ['im/auth/%s_%s.html' % (self.module, tpl),

                getattr(self, '%s_template' % tpl)]

        found = None

        for tpl in tpls:

            try:

                found = template.loader.get_template(tpl)

                return tpl

            except template.TemplateDoesNotExist:

                continue

        if not found:

            raise template.TemplateDoesNotExist

        return tpl

    def get_username(self):

        return self.get_username_msg

    def get_user_providers(self):

        return self.user.auth_providers.active()

    def get_user_module_providers(self):

        return self.user.auth_providers.active().filter(module=self.module)

    def get_existing_providers(self):

        return ""

    def verified_exists(self):

        return self.get_provider_model().objects.verified(

            self.module, identifier=self.identifier)

    def get_user_policy(self, policy, default=None):

        if policy == 'switch' and default and not self.get_add_policy:

            return not self.get_policy('remove')

        if not self.user:

            return default

        if policy == 'remove' and default is True:

            return self.get_user_providers().count() > 1

        if policy == 'add' and default is True:

            limit = self.get_policy('limit')

            if limit <= self.get_user_module_providers().count():

                return False

            if self.identifier:

                if self.verified_exists():

                    return False

        return default

    def get_user_policies(self):

        from astakos.im.models import AuthProviderPolicyProfile

        return AuthProviderPolicyProfile.objects.for_user(self.user,

                                                          self.module)

    def get_policy(self, policy):

        module_default = self.module_policies.get(policy)

        settings_key = '%s_POLICY' % policy.upper()

        settings_default = self.get_setting(settings_key, module_default)

        if self.user:

            user_policies = self.get_user_policies()

            settings_default = user_policies.get(policy, settings_default)

        return self.get_user_policy(policy, settings_default)

    def get_message(self, msg, **extra_params):

        """

        Retrieve an auth provider message

        """

        if msg.endswith('_msg'):

            msg = msg.replace('_msg', '')

        params = self._message_params(**extra_params)

        # is message ???

        tpl = self.message_tpls_compiled.get(msg.lower(), None)

        if not tpl:

            msg_key = 'AUTH_PROVIDER_%s' % msg.upper()

            try:

                tpl = getattr(astakos_messages, msg_key)

            except AttributeError, e:

                try:

                    msg_key = msg.upper()

                    tpl = getattr(astakos_messages, msg_key)

                except AttributeError, e:

                    tpl = ''

        in_settings = self.get_setting(msg)

        if in_settings:

            tpl = in_settings

        return tpl.format(**params)

    def urls(self):

        urls = {

            'login': reverse(self.login_view),

            'add': reverse(self.login_view),

            'profile': reverse('edit_profile'),

        }

            urls.update({

                'resend_activation': self.user.get_resend_activation_url(),

            })

        if self.identifier and self._instance:

            urls.update({

                'switch': reverse(self.login_view) + '?switch_from=%d' % \

                    self._instance.pk,

                'remove': reverse('remove_auth_provider',

                                  kwargs={'pk': self._instance.pk})

            })

        urls.update(self.module_urls)

        return urls

    def get_setting_key(self, name):

        return 'ASTAKOS_AUTH_PROVIDER_%s_%s' % (self.module.upper(),

                                                name.upper())

    def get_global_setting_key(self, name):

        return 'ASTAKOS_AUTH_PROVIDERS_%s' % name.upper()

    def has_global_setting(self, name):

        return hasattr(settings, self.get_global_setting_key(name))

    def has_setting(self, name):

        return hasattr(settings, self.get_setting_key(name))

    def get_setting(self, name, default=None):

        attr = self.get_setting_key(name)

        if not self.has_setting(name):

            return self.get_global_setting(name, default)

        return getattr(settings, attr, default)

    def get_global_setting(self, name, default=None):

        attr = self.get_global_setting_key(name)

        if not self.has_global_setting(name):

            return default

        return getattr(settings, attr, default)

    @property

    def provider_details(self):

        if self._provider_details:

            return self._provider_details

        self._provider_details = {}

        if self._instance:

            self._provider_details = self._instance.__dict__

        if self.user and self.identifier:

            if self.identifier:

                try:

                    self._provider_details = \

                        self.user.get_auth_providers().get(

                            module=self.module,

                            identifier=self.identifier).__dict__

                except Exception:

                    return {}

        return self._provider_details

        key = key.replace('get_', '')

        if key.endswith('_msg'):

            return self.get_message(key)

        if key.endswith('_policy'):

            return self.get_policy(key.replace('_policy', ''))

        if key.endswith('_url'):

            key = key.replace('_url', '')

            return self.urls.get(key)

        if key.endswith('_icon'):

            key = key.replace('_msg', '_icon')

            return settings.MEDIA_URL + self.get_message(key)

        if key.endswith('_setting'):

            key = key.replace('_setting', '')

            return self.get_message(key)

        if key.endswith('_template'):

            key = key.replace('_template', '')

            return self.get_template(key)

        return super(AuthProvider, self).__getattribute__(key)

        return self.module_enabled

    username_key = 'user_email'

    messages = {

        'title': _('Classic'),

        'login_prompt': _('Classic login (username/password)'),

        'login_success': _('Logged in successfully.'),

        'method_details': 'Username: {username}',

        'logout_success_extra': ' '

    }

    def urls(self):

        urls = super(LocalAuthProvider, self).urls

        urls['change_password'] = reverse('password_change')

        if self.user:

            urls['add'] = reverse('password_change')

        if self._instance:

            urls.update({

                'remove': reverse('remove_auth_provider',

                                  kwargs={'pk': self._instance.pk})

            })

            if 'switch' in urls:

                del urls['switch']

        return urls

    def remove_from_user(self):

        super(LocalAuthProvider, self).remove_from_user()

        self.user.set_unusable_password()

        self.user.save()

        for group_name in self.get_add_groups_policy:

            group = Group.objects.get(name=group_name)

            self.user.groups.remove(group)

    username_key = 'identifier'

    messages = {

        'title': _('Academic'),

        'login_description': _('If you are a student, professor or researcher'

                               ' you can login using your academic account.'),

        'method_details': 'Account: {username}',

        'logout_extra': _('Please close all browser windows to complete '

                          'logout from your Academic account, too.')

    }

    username_key = 'provider_info_screen_name'

    messages = {

        'title': _('Twitter'),

        'method_details': 'Screen name: {username}',

    }

    username_key = 'provider_info_email'

    messages = {

        'title': _('Google'),

        'method_details': 'Email: {username}',

    }

    username_key = 'provider_info_email'

    messages = {

        'title': _('LinkedIn'),

        'method_details': 'Email: {username}',

    }

# Utility method

def get_provider(module, user_obj=None, identifier=None, **params):

    if not module in PROVIDERS:

        raise Exception('Invalid auth provider "%s"' % id)

    return PROVIDERS.get(module)(user_obj, identifier, **params)

                mark_safe("I agree with %s" % terms_link_html)

            provider_id = self.request.REQUEST.get('provider', 'local')

            provider = auth_providers.get_provider(provider_id)

            extra_message = provider.get_add_to_existing_account_msg

            raise forms.ValidationError(mark_safe(_(astakos_messages.EMAIL_USED) + ' ' +

                                        extra_message))

            token=request.POST.get('third_party_token'),

            third_party_identifier=

            self.cleaned_data.get('third_party_identifier'))

        provider = pending.get_provider(user)

        provider.add_to_user()

        pending.delete()

                    provider = auth_providers.get_provider('local', user)

                        provider.get_login_disabled_msg)

                msg = self.user_cache.get_inactive_message('local')

                raise forms.ValidationError(msg)

        # we override the default django auth clean_email to provide more

        # detailed messages in case of inactive users

        email = self.cleaned_data['email']

            self.users_cache = [user]

                raise forms.ValidationError(user.get_inactive_message('local'))

            provider = auth_providers.get_provider('local', user)

                msg = provider.get_unusable_password_msg

                raise forms.ValidationError(msg)

                msg = provider.get_cannot_change_password_msg

                raise forms.ValidationError(msg)

        except AstakosUser.DoesNotExist:

            provider = auth_providers.get_provider('local', self.user)

            if provider.get_add_policy:

                provider.add_to_user()

# Copyright 2012 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

import string

from optparse import make_option

from django.core.management.base import BaseCommand, CommandError

from astakos.im.models import AuthProviderPolicyProfile as Profile

option_list = list(BaseCommand.option_list) + [

    make_option('--update',

                action='store_true',

                dest='update',

                default=False,

                help="Update an existing profile."),

    make_option('--exclusive',

                action='store_true',

                dest='exclusive',

                default=False,

                help="Apply policies to all authentication providers "

                     "except the one provided."),

]

POLICIES = ['add', 'remove', 'create', 'login', 'limit', 'required',

            'automoderate']

for p in POLICIES:

    option_list.append(make_option('--unset-%s-policy' % p,

                                   action='store_true',

                                   dest='unset_policy_%s' % p,

                                   help="Unset %s policy (only when --update)"

                                   % p.title()))

    option_list.append(make_option('--%s-policy' % p,

                                   action='store',

                                   dest='policy_%s' % p,

                                   help="%s policy" % p.title()))

class Command(BaseCommand):

    args = "<name> <provider_name>"

    help = "Create a new authentication provider policy profile"

    option_list = option_list

    def handle(self, *args, **options):

        if len(args) < 2:

            raise CommandError("Invalid number of arguments")

        profile = None

        update = options.get('update')

        name = args[0].strip()

        provider = args[1].strip()

        if Profile.objects.filter(name=name).count():

            if update:

                profile = Profile.objects.get(name=name)

            else:

                raise CommandError("Profile with the same name already exists")

        if not profile:

            profile = Profile()

        profile.name = name

        profile.provider = provider

        profile.is_exclusive = options.get('exclusive')

        for policy, value in options.iteritems():

            if policy.startswith('policy_') and value is not None:

                if isinstance(value, basestring) and value[0] in string.digits:

                    value = int(value)

                if value == 'False' or value == '0':

                    value = False

                if value == 'True' or value == '1':

                    value = True

                setattr(profile, policy, value)

            if update and policy.startswith('unset_'):

                policy = policy.replace('unset_', '')

                setattr(profile, policy, None)

        profile.save()

        if update:

            print "Profile updated"

        else:

            print "Profile stored"

# Copyright 2012 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from optparse import make_option

from django.core.management.base import NoArgsCommand

from astakos.im.models import AuthProviderPolicyProfile

from ._common import format

class Command(NoArgsCommand):

    help = "List existing authentication provider policy profiles"

    option_list = NoArgsCommand.option_list + (

        make_option('-c',

                    action='store_true',

                    dest='csv',

                    default=False,

                    help="Use pipes to separate values"),

    )

    def handle_noargs(self, **options):

        profiles = AuthProviderPolicyProfile.objects.all()

        labels = ['id', 'name', 'provider', 'exclusive', 'groups', 'users']

        columns = [3, 20, 13, 7, 50, 50]

        if not options['csv']:

            line = ' '.join(l.rjust(w) for l, w in zip(labels, columns))

            self.stdout.write(line + '\n')

            sep = '-' * len(line)

            self.stdout.write(sep + '\n')

        for profile in profiles:

            id = str(profile.pk)

            name = profile.name

            provider = profile.provider

            exclusive = str(profile.is_exclusive)

            groups = ",".join([g.name for g in profile.groups.all()])

            users = ",".join([u.email for u in profile.users.all()])

            field_values = [id, name, provider, exclusive, groups, users]

            fields = (format(elem) for elem in field_values)

            if options['csv']:

                line = '|'.join(fields)

            else:

                line = ' '.join(f.rjust(w) for f, w in zip(fields, columns))

            self.stdout.write(line + '\n')

# Copyright 2012 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from django.core.management.base import BaseCommand, CommandError

from astakos.im.models import AuthProviderPolicyProfile as Profile

class Command(BaseCommand):

    args = "<profile_name>"

    help = "Remove an authentication provider policy"

    option_list = BaseCommand.option_list + ()

    def handle(self, *args, **options):

        if len(args) != 1:

            raise CommandError("Invalid number of arguments")

        try:

            profile = Profile.objects.get(name=args[0])

            profile.delete()

        except Profile.DoesNotExist:

            raise CommandError("Invalid profile name")

# Copyright 2012 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from optparse import make_option

from django.db import transaction

from django.core.management.base import BaseCommand, CommandError

from astakos.im.models import AuthProviderPolicyProfile as Profile

from astakos.im.models import AstakosUser, Group

option_list = BaseCommand.option_list + (

    make_option('--group',

                action='append',

                dest='groups',

                default=[],

                help="Assign profile to the provided group id. Option may "

                     "be used more than once."),

    make_option('--user',

                action='append',

                dest='users',

                default=[],

                help="Assign profile to the provided user id. Option may "

                     "be used more than once.")

)

@transaction.commit_on_success

def update_profile(profile, users, groups):

    profile.groups.all().delete()

    profile.users.all().delete()

    profile.groups.add(*groups)

    profile.users.add(*users)

class Command(BaseCommand):

    args = "<name> <provider_name>"

    help = "Assign an existing authentication provider policy profile to " + \

           "a user or group. All previously set "

    option_list = option_list

    def handle(self, *args, **options):

        if len(args) < 1:

            raise CommandError("Invalid number of arguments")

        name = args[0].strip()

        try:

            profile = Profile.objects.get(name=name)

        except Profile.DoesNotExist:

            raise CommandError("Invalid profile name")

        users = []

        try:

            users = [AstakosUser.objects.get(pk=int(pk)) for pk in

                     options.get('users')]

        except AstakosUser.DoesNotExist:

            raise CommandError("Invalid user id")

        groups = []

        try:

            groups = [Group.objects.get(pk=int(pk)) for pk in

                      options.get('groups')]

        except Group.DoesNotExist:

            raise CommandError("Invalid group id")

        update_profile(profile, users, groups)

# Copyright 2012, 2013 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from django.core.management.base import BaseCommand, CommandError

from astakos.im.models import AuthProviderPolicyProfile as Profile

from synnefo.lib.ordereddict import OrderedDict

from ._common import format

import uuid

class Command(BaseCommand):

    args = "<profile_name>"

    help = "Show authentication provider profile details"

    def handle(self, *args, **options):

        if len(args) != 1:

            raise CommandError("Please profile name")

        try:

            profile = Profile.objects.get(name=args[0])

        except Profile.DoesNotExist:

            raise CommandError("Profile does not exist")

        kv = OrderedDict(

            [

                ('id', profile.id),

                ('is active', str(profile.active)),

                ('name', profile.name),

                ('is exclusive', profile.is_exclusive),

                ('policies', profile.policies),

                ('groups', profile.groups.all()),

                ('users', profile.users.all())

            ])

        self.stdout.write(format(kv))

        self.stdout.write('\n')

# Copyright 2012 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from django.core.management.base import BaseCommand, CommandError

from astakos.im.models import Group

class Command(BaseCommand):

    args = "<group name>"

    help = "Create a group with the given name"

    option_list = BaseCommand.option_list + ()

    def handle(self, *args, **options):

        if len(args) != 1:

            raise CommandError("Invalid number of arguments")

        Group.objects.get_or_create(name=args[0].strip())

        print "Group created"

# Copyright 2012 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from optparse import make_option

from django.core.management.base import NoArgsCommand

from django.db.models import Count

from astakos.im.models import Group

from ._common import format

class Command(NoArgsCommand):

    help = "List available groups"

    option_list = NoArgsCommand.option_list + (

        make_option('-c',

                    action='store_true',

                    dest='csv',

                    default=False,

                    help="Use pipes to separate values"),

    )

    def handle_noargs(self, **options):

        objects = Group.objects.annotate(

            users_count=Count('user')).order_by('id')

        labels = ['id', 'name', 'users count']

        columns = [3, 40, 20]

        if not options['csv']:

            line = ' '.join(l.rjust(w) for l, w in zip(labels, columns))

            self.stdout.write(line + '\n')

            sep = '-' * len(line)

            self.stdout.write(sep + '\n')

        for group in objects:

            id = str(group.pk)

            name = str(group.name)

            user_count = str(group.users_count)

            field_values = [id, name, user_count]

            fields = (format(elem) for elem in field_values)

            if options['csv']:

                line = '|'.join(fields)

            else: