DjNRO

SOCIAL_AUTH_PIPELINE = (

    'social_auth.backends.pipeline.social.social_auth_user',

    'social_auth.backends.pipeline.user.get_username',

    'social_auth.backends.pipeline.user.create_user',

    'social_auth.backends.pipeline.social.associate_user',

    'social_auth.backends.pipeline.social.load_extra_data',

    'social_auth.backends.pipeline.user.update_user_details',

)

"""

python-social-auth application, allows OpenId or OAuth user

registration/authentication just adding a few configurations.

"""

version = (0, 2, 1)

extra = ''

__version__ = '.'.join(map(str, version)) + extra

from social.p3 import quote

from social.utils import sanitize_redirect, user_is_authenticated, \

                         user_is_active, partial_pipeline_data, setting_url

def do_auth(backend, redirect_name='next'):

    # Save any defined next value into session

    data = backend.strategy.request_data(merge=False)

    # Save extra data into session.

    for field_name in backend.setting('FIELDS_STORED_IN_SESSION', []):

        if field_name in data:

            backend.strategy.session_set(field_name, data[field_name])

    if redirect_name in data:

        # Check and sanitize a user-defined GET/POST next field value

        redirect_uri = data[redirect_name]

        if backend.setting('SANITIZE_REDIRECTS', True):

            redirect_uri = sanitize_redirect(backend.strategy.request_host(),

                                             redirect_uri)

        backend.strategy.session_set(

            redirect_name,

            redirect_uri or backend.setting('LOGIN_REDIRECT_URL')

        )

    return backend.start()

def do_complete(backend, login, user=None, redirect_name='next',

                *args, **kwargs):

    # pop redirect value before the session is trashed on login()

    data = backend.strategy.request_data()

    redirect_value = backend.strategy.session_get(redirect_name, '') or \

                     data.get(redirect_name, '')

    is_authenticated = user_is_authenticated(user)

    user = is_authenticated and user or None

    partial = partial_pipeline_data(backend, user, *args, **kwargs)

    if partial:

        xargs, xkwargs = partial

        user = backend.continue_pipeline(*xargs, **xkwargs)

    else:

        user = backend.complete(user=user, *args, **kwargs)

    user_model = backend.strategy.storage.user.user_model()

    if user and not isinstance(user, user_model):

        return user

    if is_authenticated:

        if not user:

            url = setting_url(backend, redirect_value, 'LOGIN_REDIRECT_URL')

        else:

            url = setting_url(backend, redirect_value,

                              'NEW_ASSOCIATION_REDIRECT_URL',

                              'LOGIN_REDIRECT_URL')

    elif user:

        if user_is_active(user):

            # catch is_new/social_user in case login() resets the instance

            is_new = getattr(user, 'is_new', False)

            social_user = user.social_user

            login(backend, user, social_user)

            # store last login backend name in session

            backend.strategy.session_set('social_auth_last_login_backend',

                                         social_user.provider)

            if is_new:

                url = setting_url(backend,

                                  'NEW_USER_REDIRECT_URL',

                                  redirect_value,

                                  'LOGIN_REDIRECT_URL')

            else:

                url = setting_url(backend, redirect_value,

                                  'LOGIN_REDIRECT_URL')

        else:

            url = setting_url(backend, 'INACTIVE_USER_URL', 'LOGIN_ERROR_URL',

                              'LOGIN_URL')

    else:

        url = setting_url(backend, 'LOGIN_ERROR_URL', 'LOGIN_URL')

    if redirect_value and redirect_value != url:

        redirect_value = quote(redirect_value)

        url += ('?' in url and '&' or '?') + \

               '{0}={1}'.format(redirect_name, redirect_value)

    if backend.setting('SANITIZE_REDIRECTS', True):

        url = sanitize_redirect(backend.strategy.request_host(), url) or \

              backend.setting('LOGIN_REDIRECT_URL')

    return backend.strategy.redirect(url)

def do_disconnect(backend, user, association_id=None, redirect_name='next',

                  *args, **kwargs):

    partial = partial_pipeline_data(backend, user, *args, **kwargs)

    if partial:

        xargs, xkwargs = partial

        if association_id and not xkwargs.get('association_id'):

            xkwargs['association_id'] = association_id

        response = backend.disconnect(*xargs, **xkwargs)

    else:

        response = backend.disconnect(user=user, association_id=association_id,

                                      *args, **kwargs)

    if isinstance(response, dict):

        response = backend.strategy.redirect(

            backend.strategy.request_data().get(redirect_name, '') or

            backend.setting('DISCONNECT_REDIRECT_URL') or

            backend.setting('LOGIN_REDIRECT_URL')

        )

    return response

"""Flask SQLAlchemy ORM models for Social Auth"""

import cherrypy

from sqlalchemy import Column, Integer, String, ForeignKey

from sqlalchemy.orm import relationship

from sqlalchemy.ext.declarative import declarative_base

from social.utils import setting_name, module_member

from social.storage.sqlalchemy_orm import SQLAlchemyUserMixin, \

                                          SQLAlchemyAssociationMixin, \

                                          SQLAlchemyNonceMixin, \

                                          BaseSQLAlchemyStorage

SocialBase = declarative_base()

DB_SESSION_ATTR = cherrypy.config.get(setting_name('DB_SESSION_ATTR'), 'db')

UID_LENGTH = cherrypy.config.get(setting_name('UID_LENGTH'), 255)

User = module_member(cherrypy.config[setting_name('USER_MODEL')])

class CherryPySocialBase(object):

    @classmethod

    def _session(cls):

        return getattr(cherrypy.request, DB_SESSION_ATTR)

class UserSocialAuth(CherryPySocialBase, SQLAlchemyUserMixin, SocialBase):

    """Social Auth association model"""

    uid = Column(String(UID_LENGTH))

    user_id = Column(Integer, ForeignKey(User.id),

                     nullable=False, index=True)

    user = relationship(User, backref='social_auth')

    @classmethod

    def username_max_length(cls):

        return User.__table__.columns.get('username').type.length

    @classmethod

    def user_model(cls):

        return User

class Nonce(CherryPySocialBase, SQLAlchemyNonceMixin, SocialBase):

    """One use numbers"""

    pass

class Association(CherryPySocialBase, SQLAlchemyAssociationMixin, SocialBase):

    """OpenId account association"""

    pass

class CherryPyStorage(BaseSQLAlchemyStorage):

    user = UserSocialAuth

    nonce = Nonce

    association = Association

import warnings

from functools import wraps

import cherrypy

from social.utils import setting_name, module_member

from social.strategies.utils import get_strategy

from social.backends.utils import get_backend, user_backends_data

DEFAULTS = {

    'STRATEGY': 'social.strategies.cherrypy_strategy.CherryPyStrategy',

    'STORAGE': 'social.apps.cherrypy_app.models.CherryPyStorage'

}

def get_helper(name):

    return cherrypy.config.get(setting_name(name), DEFAULTS.get(name, None))

def load_backend(strategy, name, redirect_uri):

    backends = get_helper('AUTHENTICATION_BACKENDS')

    Backend = get_backend(backends, name)

    return Backend(strategy=strategy, redirect_uri=redirect_uri)

def psa(redirect_uri=None):

    def decorator(func):

        @wraps(func)

        def wrapper(self, backend=None, *args, **kwargs):

            uri = redirect_uri

            if uri and backend and '%(backend)s' in uri:

                uri = uri % {'backend': backend}

            self.strategy = get_strategy(get_helper('STRATEGY'),

                                         get_helper('STORAGE'))

            self.backend = load_backend(self.strategy, backend, uri)

            return func(self, backend, *args, **kwargs)

        return wrapper

    return decorator

def backends(user):

    """Load Social Auth current user data to context under the key 'backends'.

    Will return the output of social.backends.utils.user_backends_data."""

    return user_backends_data(user, get_helper('AUTHENTICATION_BACKENDS'),

                              module_member(get_helper('STORAGE')))

def strategy(*args, **kwargs):

    warnings.warn('@strategy decorator is deprecated, use @psa instead')

    return psa(*args, **kwargs)

import cherrypy

from social.utils import setting_name, module_member

from social.actions import do_auth, do_complete, do_disconnect

from social.apps.cherrypy_app.utils import psa

class CherryPyPSAViews(object):

    @cherrypy.expose

    @psa('/complete/%(backend)s')

    def login(self, backend):

        return do_auth(self.backend)

    @cherrypy.expose

    @psa('/complete/%(backend)s')

    def complete(self, backend, *args, **kwargs):

        login = cherrypy.config.get(setting_name('LOGIN_METHOD'))

        do_login = module_member(login) if login else self.do_login

        user = getattr(cherrypy.request, 'user', None)

        return do_complete(self.backend, do_login, user=user, *args, **kwargs)

    @cherrypy.expose

    @psa()

    def disconnect(self, backend, association_id=None):

        user = getattr(cherrypy.request, 'user', None)

        return do_disconnect(self.backend, user, association_id)

    def do_login(self, backend, user, social_user):

        backend.strategy.session_set('user_id', user.id)

"""

Django framework support.

To use this:

  * Add 'social.apps.django_app.default' if using default ORM,

    or 'social.apps.django_app.me' if using mongoengine

  * Add url('', include('social.apps.django_app.urls', namespace='social')) to

    urls.py

  * Define SOCIAL_AUTH_STORAGE and SOCIAL_AUTH_STRATEGY, default values:

    SOCIAL_AUTH_STRATEGY = 'social.strategies.django_strategy.DjangoStrategy'

    SOCIAL_AUTH_STORAGE = 'social.apps.django_app.default.models.DjangoStorage'

"""

from social.strategies.utils import set_current_strategy_getter

from social.apps.django_app.utils import load_strategy

# Set strategy loader method to workaround current strategy getter needed on

# get_user() method on authentication backends when working with Django

set_current_strategy_getter(load_strategy)

from django.contrib.auth import REDIRECT_FIELD_NAME

from django.utils.functional import SimpleLazyObject

try:

    from django.utils.functional import empty as _empty

    empty = _empty

except ImportError:  # django < 1.4

    empty = None

from social.backends.utils import user_backends_data

from social.apps.django_app.utils import Storage, BACKENDS

class LazyDict(SimpleLazyObject):

    """Lazy dict initialization."""

    def __getitem__(self, name):

        if self._wrapped is empty:

            self._setup()

        return self._wrapped[name]

    def __setitem__(self, name, value):

        if self._wrapped is empty:

            self._setup()

        self._wrapped[name] = value

def backends(request):

    """Load Social Auth current user data to context under the key 'backends'.

    Will return the output of social.backends.utils.user_backends_data."""

    return {'backends': LazyDict(lambda: user_backends_data(request.user,

                                                            BACKENDS,

                                                            Storage))}

def login_redirect(request):

    """Load current redirect to context."""

    value = request.method == 'POST' and \

                request.POST.get(REDIRECT_FIELD_NAME) or \

                request.GET.get(REDIRECT_FIELD_NAME)

    querystring = value and (REDIRECT_FIELD_NAME + '=' + value) or ''

    return {

        'REDIRECT_FIELD_NAME': REDIRECT_FIELD_NAME,

        'REDIRECT_FIELD_VALUE': value,

        'REDIRECT_QUERYSTRING': querystring

    }

"""

Django default ORM backend support.

To enable this app:

    * Add 'social.apps.django_app.default' to INSTALLED_APPS

    * In urls.py include url('', include('social.apps.django_app.urls'))

"""

"""Admin settings"""

from django.conf import settings

from django.contrib import admin

from social.utils import setting_name

from social.apps.django_app.default.models import UserSocialAuth, Nonce, \

                                                  Association

class UserSocialAuthOption(admin.ModelAdmin):

    """Social Auth user options"""

    list_display = ('id', 'user', 'provider', 'uid')

    list_filter = ('provider',)

    raw_id_fields = ('user',)

    list_select_related = True

    def get_search_fields(self, request=None):

        search_fields = getattr(

            settings, setting_name('ADMIN_USER_SEARCH_FIELDS'), None

        )

        if search_fields is None:

            _User = UserSocialAuth.user_model()

            username = getattr(_User, 'USERNAME_FIELD', None) or \

                       hasattr(_User, 'username') and 'username' or \

                       None

            fieldnames = ('first_name', 'last_name', 'email', username)

            all_names = _User._meta.get_all_field_names()

            search_fields = [name for name in fieldnames

                                if name and name in all_names]

        return ['user__' + name for name in search_fields]

class NonceOption(admin.ModelAdmin):

    """Nonce options"""

    list_display = ('id', 'server_url', 'timestamp', 'salt')

    search_fields = ('server_url',)

class AssociationOption(admin.ModelAdmin):

    """Association options"""

    list_display = ('id', 'server_url', 'assoc_type')

    list_filter = ('assoc_type',)

    search_fields = ('server_url',)

admin.site.register(UserSocialAuth, UserSocialAuthOption)

admin.site.register(Nonce, NonceOption)

admin.site.register(Association, AssociationOption)

import json

import six

from django.core.exceptions import ValidationError

from django.db import models

try:

    from django.utils.encoding import smart_unicode as smart_text

    smart_text  # placate pyflakes

except ImportError:

    from django.utils.encoding import smart_text

class JSONField(six.with_metaclass(models.SubfieldBase, models.TextField)):

    """Simple JSON field that stores python structures as JSON strings

    on database.

    """

    def __init__(self, *args, **kwargs):

        kwargs.setdefault('default', '{}')

        super(JSONField, self).__init__(*args, **kwargs)

    def to_python(self, value):

        """

        Convert the input JSON value into python structures, raises

        django.core.exceptions.ValidationError if the data can't be converted.

        """

        if self.blank and not value:

            return {}

        value = value or '{}'

        if isinstance(value, six.binary_type):

            value = six.text_type(value, 'utf-8')

        if isinstance(value, six.string_types):

            try:

                # with django 1.6 i have '"{}"' as default value here

                if value[0] == value[-1] == '"':

                    value = value[1:-1]

                return json.loads(value)

            except Exception as err:

                raise ValidationError(str(err))

        else:

            return value

    def validate(self, value, model_instance):

        """Check value is a valid JSON string, raise ValidationError on

        error."""

        if isinstance(value, six.string_types):

            super(JSONField, self).validate(value, model_instance)

            try:

                json.loads(value)

            except Exception as err:

                raise ValidationError(str(err))

    def get_prep_value(self, value):

        """Convert value to JSON string before save"""

        try:

            return json.dumps(value)

        except Exception as err:

            raise ValidationError(str(err))

    def value_to_string(self, obj):

        """Return value from object converted to string properly"""

        return smart_text(self.get_prep_value(self._get_val_from_obj(obj)))

    def value_from_object(self, obj):

        """Return value dumped to string."""

        return self.get_prep_value(self._get_val_from_obj(obj))

try:

    from south.modelsinspector import add_introspection_rules

    add_introspection_rules(

        [],

        ["^social\.apps\.django_app\.default\.fields\.JSONField"]

    )

except:

    pass

# -*- coding: utf-8 -*-

from __future__ import unicode_literals

from django.db import models, migrations

from django.conf import settings

import social.storage.django_orm

import social.apps.django_app.default.fields

class Migration(migrations.Migration):

    dependencies = [

        migrations.swappable_dependency(settings.AUTH_USER_MODEL),

    ]

    operations = [

        migrations.CreateModel(

            name='Association',

            fields=[

                ('id', models.AutoField(serialize=False, primary_key=True,

                                        auto_created=True, verbose_name='ID')),

                ('server_url', models.CharField(max_length=255)),

                ('handle', models.CharField(max_length=255)),

                ('secret', models.CharField(max_length=255)),

                ('issued', models.IntegerField()),

                ('lifetime', models.IntegerField()),

                ('assoc_type', models.CharField(max_length=64)),

            ],

            options={

                'db_table': 'social_auth_association',

            },

            bases=(

                models.Model,

                social.storage.django_orm.DjangoAssociationMixin

            ),

        ),

        migrations.CreateModel(

            name='Code',

            fields=[

                ('id', models.AutoField(serialize=False, primary_key=True,

                                        auto_created=True, verbose_name='ID')),

                ('email', models.EmailField(max_length=75)),

                ('code', models.CharField(db_index=True, max_length=32)),

                ('verified', models.BooleanField(default=False)),

            ],

            options={

                'db_table': 'social_auth_code',

            },

            bases=(models.Model, social.storage.django_orm.DjangoCodeMixin),

        ),

        migrations.AlterUniqueTogether(

            name='code',

            unique_together=set([('email', 'code')]),

        ),

        migrations.CreateModel(

            name='Nonce',

            fields=[

                ('id', models.AutoField(serialize=False, primary_key=True,

                                        auto_created=True, verbose_name='ID')),

                ('server_url', models.CharField(max_length=255)),

                ('timestamp', models.IntegerField()),

                ('salt', models.CharField(max_length=65)),

            ],

            options={

                'db_table': 'social_auth_nonce',

            },

            bases=(models.Model, social.storage.django_orm.DjangoNonceMixin),

        ),

        migrations.CreateModel(

            name='UserSocialAuth',

            fields=[

                ('id', models.AutoField(serialize=False, primary_key=True,

                                        auto_created=True, verbose_name='ID')),

                ('provider', models.CharField(max_length=32)),

                ('uid', models.CharField(max_length=255)),

                ('extra_data',

                 social.apps.django_app.default.fields.JSONField(default='{}')

                ),

                ('user', models.ForeignKey(to=settings.AUTH_USER_MODEL)),

            ],

            options={

                'db_table': 'social_auth_usersocialauth',

            },

            bases=(models.Model, social.storage.django_orm.DjangoUserMixin),

        ),

        migrations.AlterUniqueTogether(

            name='usersocialauth',

            unique_together=set([('provider', 'uid')]),

        ),

    ]

"""Django ORM models for Social Auth"""

import six

from django.db import models

from django.conf import settings

from django.db.utils import IntegrityError

from social.utils import setting_name

from social.storage.django_orm import DjangoUserMixin, \

                                      DjangoAssociationMixin, \

                                      DjangoNonceMixin, \

                                      DjangoCodeMixin, \

                                      BaseDjangoStorage

from social.apps.django_app.default.fields import JSONField

USER_MODEL = getattr(settings, setting_name('USER_MODEL'), None) or \

             getattr(settings, 'AUTH_USER_MODEL', None) or \

             'auth.User'

UID_LENGTH = getattr(settings, setting_name('UID_LENGTH'), 255)

NONCE_SERVER_URL_LENGTH = getattr(

    settings, setting_name('NONCE_SERVER_URL_LENGTH'), 255)

ASSOCIATION_SERVER_URL_LENGTH = getattr(

    settings, setting_name('ASSOCIATION_SERVER_URL_LENGTH'), 255)

ASSOCIATION_HANDLE_LENGTH = getattr(

    settings, setting_name('ASSOCIATION_HANDLE_LENGTH'), 255)

class UserSocialAuth(models.Model, DjangoUserMixin):

    """Social Auth association model"""

    user = models.ForeignKey(USER_MODEL, related_name='social_auth')

    provider = models.CharField(max_length=32)

    uid = models.CharField(max_length=UID_LENGTH)

    extra_data = JSONField()

    class Meta:

        """Meta data"""

        unique_together = ('provider', 'uid')

        db_table = 'social_auth_usersocialauth'

    @classmethod

    def get_social_auth(cls, provider, uid):

        try:

            return cls.objects.select_related('user').get(provider=provider,

                                                          uid=uid)

        except UserSocialAuth.DoesNotExist:

            return None

    @classmethod

    def username_max_length(cls):

        username_field = cls.username_field()

        field = UserSocialAuth.user_model()._meta.get_field(username_field)

        return field.max_length

    @classmethod

    def user_model(cls):

        user_model = UserSocialAuth._meta.get_field('user').rel.to

        if isinstance(user_model, six.string_types):

            app_label, model_name = user_model.split('.')

            return models.get_model(app_label, model_name)

        return user_model

class Nonce(models.Model, DjangoNonceMixin):

    """One use numbers"""

    server_url = models.CharField(max_length=NONCE_SERVER_URL_LENGTH)

    timestamp = models.IntegerField()

    salt = models.CharField(max_length=65)

    class Meta:

        db_table = 'social_auth_nonce'

class Association(models.Model, DjangoAssociationMixin):

    """OpenId account association"""

    server_url = models.CharField(max_length=ASSOCIATION_SERVER_URL_LENGTH)

    handle = models.CharField(max_length=ASSOCIATION_HANDLE_LENGTH)

    secret = models.CharField(max_length=255)  # Stored base64 encoded

    issued = models.IntegerField()

    lifetime = models.IntegerField()

    assoc_type = models.CharField(max_length=64)

    class Meta:

        db_table = 'social_auth_association'

class Code(models.Model, DjangoCodeMixin):

    email = models.EmailField()

    code = models.CharField(max_length=32, db_index=True)

    verified = models.BooleanField(default=False)

    class Meta:

        db_table = 'social_auth_code'

        unique_together = ('email', 'code')

class DjangoStorage(BaseDjangoStorage):

    user = UserSocialAuth

    nonce = Nonce

    association = Association

    code = Code

    @classmethod

    def is_integrity_error(cls, exception):

        return exception.__class__ is IntegrityError

# -*- coding: utf-8 -*-

from south.db import db

from south.v2 import SchemaMigration

from . import get_custom_user_model_for_migrations, custom_user_frozen_models

USER_MODEL = get_custom_user_model_for_migrations()

class Migration(SchemaMigration):

    def forwards(self, orm):

        # Adding model 'UserSocialAuth'

        db.create_table('social_auth_usersocialauth', (

            (u'id', self.gf('django.db.models.fields.AutoField')(

                primary_key=True)),

            ('user', self.gf('django.db.models.fields.related.ForeignKey')(

                related_name='social_auth', to=orm[USER_MODEL])),

            ('provider', self.gf('django.db.models.fields.CharField')(

                max_length=32)),

            ('uid', self.gf('django.db.models.fields.CharField')(

                max_length=255)),

            ('extra_data', self.gf(

                'social.apps.django_app.default.fields.JSONField'

            )(default='{}')),

        ))

        db.send_create_signal(u'default', ['UserSocialAuth'])

        # Adding unique constraint on 'UserSocialAuth',

        # fields ['provider', 'uid']

        db.create_unique('social_auth_usersocialauth', ['provider', 'uid'])

        # Adding model 'Nonce'

        db.create_table('social_auth_nonce', (

            (u'id', self.gf('django.db.models.fields.AutoField')(

                primary_key=True)),

            ('server_url', self.gf('django.db.models.fields.CharField')(

                max_length=255)),

            ('timestamp', self.gf('django.db.models.fields.IntegerField')()),

            ('salt', self.gf('django.db.models.fields.CharField')(

                max_length=65)),

        ))

        db.send_create_signal(u'default', ['Nonce'])

        # Adding model 'Association'

        db.create_table('social_auth_association', (

            (u'id', self.gf('django.db.models.fields.AutoField')(

                primary_key=True)),

            ('server_url', self.gf('django.db.models.fields.CharField')(

                max_length=255)),

            ('handle', self.gf('django.db.models.fields.CharField')(

                max_length=255)),

            ('secret', self.gf('django.db.models.fields.CharField')(

                max_length=255)),

            ('issued', self.gf('django.db.models.fields.IntegerField')()),

            ('lifetime', self.gf('django.db.models.fields.IntegerField')()),

            ('assoc_type', self.gf('django.db.models.fields.CharField')(

                max_length=64)),

        ))

        db.send_create_signal(u'default', ['Association'])

        # Adding model 'Code'

        db.create_table('social_auth_code', (

            (u'id', self.gf('django.db.models.fields.AutoField')(

                primary_key=True)),

            ('email', self.gf('django.db.models.fields.EmailField')(

                max_length=75)),

            ('code', self.gf('django.db.models.fields.CharField')(

                max_length=32,

                db_index=True)),

            ('verified', self.gf('django.db.models.fields.BooleanField')(

                default=False)),

        ))

        db.send_create_signal(u'default', ['Code'])

        # Adding unique constraint on 'Code', fields ['email', 'code']

        db.create_unique('social_auth_code', ['email', 'code'])

    def backwards(self, orm):

        # Removing unique constraint on 'Code', fields ['email', 'code']

        db.delete_unique('social_auth_code', ['email', 'code'])

        # Removing unique constraint on 'UserSocialAuth',

        # fields ['provider', 'uid']

        db.delete_unique('social_auth_usersocialauth', ['provider', 'uid'])

        # Deleting model 'UserSocialAuth'

        db.delete_table('social_auth_usersocialauth')

        # Deleting model 'Nonce'

        db.delete_table('social_auth_nonce')

        # Deleting model 'Association'

        db.delete_table('social_auth_association')

        # Deleting model 'Code'

        db.delete_table('social_auth_code')

    models = {

        u'auth.group': {

            'Meta': {'object_name': 'Group'},

            u'id': ('django.db.models.fields.AutoField', [],

                    {'primary_key': 'True'}),

            'name': ('django.db.models.fields.CharField', [],

                     {'unique': 'True', 'max_length': '80'}),

            'permissions': ('django.db.models.fields.related.ManyToManyField',

                            [], {'to': u"orm['auth.Permission']",

                                 'symmetrical': 'False', 'blank': 'True'})

        },

        u'auth.permission': {

            'Meta': {

                'ordering':

                    "(u'content_type__app_label', "

                    "u'content_type__model', u'codename')",

                'unique_together': "((u'content_type', u'codename'),)",

                'object_name': 'Permission'

            },

            'codename': ('django.db.models.fields.CharField', [],

                         {'max_length': '100'}),

            'content_type': ('django.db.models.fields.related.ForeignKey', [],

                             {'to': u"orm['contenttypes.ContentType']"}),

            u'id': ('django.db.models.fields.AutoField', [],

                    {'primary_key': 'True'}),

            'name': ('django.db.models.fields.CharField', [],

                     {'max_length': '50'})

        },

        u'auth.user': {

            'Meta': {'object_name': 'User'},

            'date_joined': ('django.db.models.fields.DateTimeField', [],

                            {'default': 'datetime.datetime.now'}),

            'email': ('django.db.models.fields.EmailField', [],

                      {'max_length': '75', 'blank': 'True'}),

            'first_name': ('django.db.models.fields.CharField', [],

                           {'max_length': '30', 'blank': 'True'}),

            'groups': ('django.db.models.fields.related.ManyToManyField', [],

                       {'symmetrical': 'False', 'related_name': "u'user_set'",

                        'blank': 'True', 'to': u"orm['auth.Group']"}),

            u'id': ('django.db.models.fields.AutoField', [],

                    {'primary_key': 'True'}),

            'is_active': ('django.db.models.fields.BooleanField', [],

                          {'default': 'True'}),

            'is_staff': ('django.db.models.fields.BooleanField', [],

                         {'default': 'False'}),

            'is_superuser': ('django.db.models.fields.BooleanField', [],

                             {'default': 'False'}),

            'last_login': ('django.db.models.fields.DateTimeField', [],

                           {'default': 'datetime.datetime.now'}),

            'last_name': ('django.db.models.fields.CharField', [],

                          {'max_length': '30', 'blank': 'True'}),

            'password': ('django.db.models.fields.CharField', [],

                         {'max_length': '128'}),

            'user_permissions': (

                'django.db.models.fields.related.ManyToManyField', [],

                {'symmetrical': 'False', 'related_name': "u'user_set'",

                 'blank': 'True', 'to': u"orm['auth.Permission']"}),

            'username': ('django.db.models.fields.CharField', [],

                         {'unique': 'True', 'max_length': '30'})

        },

        u'contenttypes.contenttype': {

            'Meta': {'ordering': "('name',)",

                     'unique_together': "(('app_label', 'model'),)",

                     'object_name': 'ContentType',

                     'db_table': "'django_content_type'"},

            'app_label': ('django.db.models.fields.CharField', [],

                          {'max_length': '100'}),

            u'id': ('django.db.models.fields.AutoField', [],

                    {'primary_key': 'True'}),

            'model': ('django.db.models.fields.CharField', [],

                      {'max_length': '100'}),

            'name': ('django.db.models.fields.CharField', [],

                     {'max_length': '100'})

        },

        u'default.association': {

            'Meta': {'object_name': 'Association',

                     'db_table': "'social_auth_association'"},

            'assoc_type': ('django.db.models.fields.CharField', [],

                           {'max_length': '64'}),

            'handle': ('django.db.models.fields.CharField', [],

                       {'max_length': '255'}),

            u'id': ('django.db.models.fields.AutoField', [],

                    {'primary_key': 'True'}),

            'issued': ('django.db.models.fields.IntegerField', [], {}),

            'lifetime': ('django.db.models.fields.IntegerField', [], {}),

            'secret': ('django.db.models.fields.CharField', [],

                       {'max_length': '255'}),

            'server_url': ('django.db.models.fields.CharField', [],

                           {'max_length': '255'})

        },

        u'default.code': {

            'Meta': {'unique_together': "(('email', 'code'),)",

                     'object_name': 'Code', 'db_table': "'social_auth_code'"},

            'code': ('django.db.models.fields.CharField', [],

                     {'max_length': '32', 'db_index': 'True'}),

            'email': ('django.db.models.fields.EmailField', [],

                      {'max_length': '75'}),

            u'id': ('django.db.models.fields.AutoField', [],

                    {'primary_key': 'True'}),

            'verified': ('django.db.models.fields.BooleanField', [],

                         {'default': 'False'})

        },

        u'default.nonce': {

            'Meta': {'object_name': 'Nonce',

                     'db_table': "'social_auth_nonce'"},

            u'id': ('django.db.models.fields.AutoField', [],

                    {'primary_key': 'True'}),

            'salt': ('django.db.models.fields.CharField', [],

                     {'max_length': '65'}),

            'server_url': ('django.db.models.fields.CharField', [],

                           {'max_length': '255'}),

            'timestamp': ('django.db.models.fields.IntegerField', [], {})

        },

        u'default.usersocialauth': {

            'Meta': {'unique_together': "(('provider', 'uid'),)",

                     'object_name': 'UserSocialAuth',

                     'db_table': "'social_auth_usersocialauth'"},

            'extra_data': ('social.apps.django_app.default.fields.JSONField',

                           [], {'default': "'{}'"}),

            u'id': ('django.db.models.fields.AutoField', [],

                    {'primary_key': 'True'}),

            'provider': ('django.db.models.fields.CharField', [],

                         {'max_length': '32'}),

            'uid': ('django.db.models.fields.CharField', [],

                    {'max_length': '255'}),

            'user': ('django.db.models.fields.related.ForeignKey', [],

                     {'related_name': "'social_auth'",

                      'to': u"orm['auth.User']"})

        }

    }

    models.update(custom_user_frozen_models(USER_MODEL))

    complete_apps = ['default']

from django.conf import settings

from django.db.models.loading import get_model

def get_custom_user_model_for_migrations():

    user_model = getattr(settings, 'SOCIAL_AUTH_USER_MODEL', None) or \

                 getattr(settings, 'AUTH_USER_MODEL', None) or \

                 'auth.User'

    if user_model != 'auth.User':

        # In case of having a proxy model defined as USER_MODEL

        # We use auth.User instead to prevent migration errors

        # Since proxy models aren't present in migrations

        if get_model(*user_model.split('.'))._meta.proxy:

            user_model = 'auth.User'

    return user_model

def custom_user_frozen_models(user_model):

    migration_name = getattr(settings, 'INITIAL_CUSTOM_USER_MIGRATION',

                             '0001_initial.py')

    if user_model != 'auth.User':

        from south.migration.base import Migrations

        from south.exceptions import NoMigrations

        from south.creator.freezer import freeze_apps

        user_app, user_model = user_model.split('.')

        try:

            user_migrations = Migrations(user_app)

        except NoMigrations:

            extra_model = freeze_apps(user_app)

        else:

            initial_user_migration = user_migrations.migration(migration_name)

            extra_model = initial_user_migration.migration_class().models

    else:

        extra_model = {}

    return extra_model

from social.apps.django_app.tests import *

"""

Mongoengine backend support.

To enable this app:

    * Add 'social.apps.django_app.me' to INSTALLED_APPS

    * In urls.py include url('', include('social.apps.django_app.urls'))

"""

"""

MongoEngine Django models for Social Auth.

Requires MongoEngine 0.8.6 or higher.

"""

from django.conf import settings

from mongoengine import Document, ReferenceField

from mongoengine.queryset import OperationError

from social.utils import setting_name, module_member

from social.storage.django_orm import BaseDjangoStorage

from social.storage.mongoengine_orm import MongoengineUserMixin, \

                                           MongoengineNonceMixin, \

                                           MongoengineAssociationMixin, \

                                           MongoengineCodeMixin

UNUSABLE_PASSWORD = '!'  # Borrowed from django 1.4

def _get_user_model():

    """

    Get the User Document class user for MongoEngine authentication.

    Use the model defined in SOCIAL_AUTH_USER_MODEL if defined, or

    defaults to MongoEngine's configured user document class.

    """

    custom_model = getattr(settings, setting_name('USER_MODEL'), None)

    if custom_model:

        return module_member(custom_model)

    try:

        # Custom user model support with MongoEngine 0.8

        from mongoengine.django.mongo_auth.models import get_user_document

        return get_user_document()

    except ImportError:

        return module_member('mongoengine.django.auth.User')

USER_MODEL = _get_user_model()

class UserSocialAuth(Document, MongoengineUserMixin):

    """Social Auth association model"""

    user = ReferenceField(USER_MODEL)

    @classmethod

    def user_model(cls):

        return USER_MODEL

class Nonce(Document, MongoengineNonceMixin):

    """One use numbers"""

    pass

class Association(Document, MongoengineAssociationMixin):

    """OpenId account association"""

    pass

class Code(Document, MongoengineCodeMixin):

    """Mail validation single one time use code"""

    pass

class DjangoStorage(BaseDjangoStorage):

    user = UserSocialAuth

    nonce = Nonce

    association = Association

    code = Code

    @classmethod

    def is_integrity_error(cls, exception):

        return exception.__class__ is OperationError and \

               'E11000' in exception.message

from social.apps.django_app.tests import *

# -*- coding: utf-8 -*-

import six

from django.conf import settings

from django.contrib import messages

from django.contrib.messages.api import MessageFailure

from django.shortcuts import redirect

from django.utils.http import urlquote

from social.exceptions import SocialAuthBaseException

class SocialAuthExceptionMiddleware(object):

    """Middleware that handles Social Auth AuthExceptions by providing the user

    with a message, logging an error, and redirecting to some next location.

    By default, the exception message itself is sent to the user and they are

    redirected to the location specified in the SOCIAL_AUTH_LOGIN_ERROR_URL

    setting.

    This middleware can be extended by overriding the get_message or

    get_redirect_uri methods, which each accept request and exception.

    """

    def process_exception(self, request, exception):

        strategy = getattr(request, 'social_strategy', None)

        if strategy is None or self.raise_exception(request, exception):

            return

        if isinstance(exception, SocialAuthBaseException):

            backend_name = request.backend.name

            message = self.get_message(request, exception)

            url = self.get_redirect_uri(request, exception)

            try:

                messages.error(request, message,

                               extra_tags='social-auth ' + backend_name)

            except MessageFailure:

                url += ('?' in url and '&' or '?') + \

                       'message={0}&backend={1}'.format(urlquote(message),

                                                        backend_name)

            return redirect(url)

    def raise_exception(self, request, exception):

        strategy = getattr(request, 'social_strategy', None)

        if strategy is not None:

            return strategy.setting('RAISE_EXCEPTIONS', settings.DEBUG)

    def get_message(self, request, exception):

        return six.text_type(exception)

    def get_redirect_uri(self, request, exception):

        strategy = getattr(request, 'social_strategy', None)

        return strategy.setting('LOGIN_ERROR_URL')

from social.tests.test_exceptions import *

from social.tests.test_pipeline import *

from social.tests.test_storage import *

from social.tests.test_utils import *

from social.tests.actions.test_associate import *

from social.tests.actions.test_disconnect import *

from social.tests.actions.test_login import *

from social.tests.backends.test_amazon import *

from social.tests.backends.test_angel import *

from social.tests.backends.test_behance import *

from social.tests.backends.test_bitbucket import *

from social.tests.backends.test_box import *

from social.tests.backends.test_broken import *

from social.tests.backends.test_coinbase import *

from social.tests.backends.test_dailymotion import *

from social.tests.backends.test_disqus import *

from social.tests.backends.test_dropbox import *

from social.tests.backends.test_dummy import *

from social.tests.backends.test_email import *

from social.tests.backends.test_evernote import *

from social.tests.backends.test_facebook import *

from social.tests.backends.test_fitbit import *

from social.tests.backends.test_flickr import *

from social.tests.backends.test_foursquare import *

from social.tests.backends.test_google import *

from social.tests.backends.test_instagram import *

from social.tests.backends.test_linkedin import *

from social.tests.backends.test_live import *

from social.tests.backends.test_livejournal import *

from social.tests.backends.test_mixcloud import *

from social.tests.backends.test_podio import *

from social.tests.backends.test_readability import *

from social.tests.backends.test_reddit import *

from social.tests.backends.test_skyrock import *

from social.tests.backends.test_soundcloud import *

from social.tests.backends.test_stackoverflow import *

from social.tests.backends.test_steam import *

from social.tests.backends.test_stocktwits import *

from social.tests.backends.test_stripe import *

from social.tests.backends.test_thisismyjam import *

from social.tests.backends.test_tripit import *

from social.tests.backends.test_tumblr import *

from social.tests.backends.test_twitter import *

from social.tests.backends.test_username import *

from social.tests.backends.test_utils import *

from social.tests.backends.test_vk import *

from social.tests.backends.test_xing import *

from social.tests.backends.test_yahoo import *

from social.tests.backends.test_yammer import *

from social.tests.backends.test_yandex import *

"""URLs module"""

try:

    from django.conf.urls import patterns, url

except ImportError:

    # Django < 1.4

    from django.conf.urls.defaults import patterns, url

urlpatterns = patterns('social.apps.django_app.views',

    # authentication / association

    url(r'^login/(?P<backend>[^/]+)/$', 'auth',

        name='begin'),

    url(r'^complete/(?P<backend>[^/]+)/$', 'complete',

        name='complete'),

    # disconnection

    url(r'^disconnect/(?P<backend>[^/]+)/$', 'disconnect',

        name='disconnect'),

    url(r'^disconnect/(?P<backend>[^/]+)/(?P<association_id>[^/]+)/$',

        'disconnect', name='disconnect_individual'),

)

import warnings

from functools import wraps

from django.conf import settings

from django.core.urlresolvers import reverse

from django.http import Http404

from social.utils import setting_name, module_member

from social.exceptions import MissingBackend

from social.strategies.utils import get_strategy

from social.backends.utils import get_backend

BACKENDS = settings.AUTHENTICATION_BACKENDS

STRATEGY = getattr(settings, setting_name('STRATEGY'),

                   'social.strategies.django_strategy.DjangoStrategy')

STORAGE = getattr(settings, setting_name('STORAGE'),

                  'social.apps.django_app.default.models.DjangoStorage')

Strategy = module_member(STRATEGY)

Storage = module_member(STORAGE)

def load_strategy(request=None):

    return get_strategy(STRATEGY, STORAGE, request)

def load_backend(strategy, name, redirect_uri):

    Backend = get_backend(BACKENDS, name)

    return Backend(strategy, redirect_uri)

def psa(redirect_uri=None, load_strategy=load_strategy):

    def decorator(func):

        @wraps(func)

        def wrapper(request, backend, *args, **kwargs):

            uri = redirect_uri

            if uri and not uri.startswith('/'):

                uri = reverse(redirect_uri, args=(backend,))

            request.social_strategy = load_strategy(request)

            # backward compatibility in attribute name, only if not already

            # defined

            if not hasattr(request, 'strategy'):

                request.strategy = request.social_strategy

            try:

                request.backend = load_backend(request.social_strategy,

                                               backend, uri)

            except MissingBackend:

                raise Http404('Backend not found')

            return func(request, backend, *args, **kwargs)

        return wrapper

    return decorator

def setting(name, default=None):

    try:

        return getattr(settings, setting_name(name))

    except AttributeError:

        return getattr(settings, name, default)

class BackendWrapper(object):

    # XXX: Deprecated, restored to avoid session issues

    def authenticate(self, *args, **kwargs):

        return None

    def get_user(self, user_id):

        return Strategy(storage=Storage).get_user(user_id)

def strategy(*args, **kwargs):

    warnings.warn('@strategy decorator is deprecated, use @psa instead')

    return psa(*args, **kwargs)

from django.contrib.auth import login, REDIRECT_FIELD_NAME

from django.contrib.auth.decorators import login_required

from django.views.decorators.csrf import csrf_exempt, csrf_protect

from django.views.decorators.http import require_POST

from social.actions import do_auth, do_complete, do_disconnect

from social.apps.django_app.utils import psa

@psa('social:complete')

def auth(request, backend):

    return do_auth(request.backend, redirect_name=REDIRECT_FIELD_NAME)

@csrf_exempt

@psa('social:complete')

def complete(request, backend, *args, **kwargs):

    """Authentication complete view"""

    return do_complete(request.backend, _do_login, request.user,

                       redirect_name=REDIRECT_FIELD_NAME, *args, **kwargs)

@login_required

@psa()

@require_POST

@csrf_protect

def disconnect(request, backend, association_id=None):

    """Disconnects given backend from current logged in user."""

    return do_disconnect(request.backend, request.user, association_id,

                         redirect_name=REDIRECT_FIELD_NAME)

def _do_login(backend, user, social_user):

    user.backend = '{0}.{1}'.format(backend.__module__,

                                  backend.__class__.__name__)

    login(backend.strategy.request, user)

    if backend.setting('SESSION_EXPIRATION', False):

        # Set session expiration date if present and enabled

        # by setting. Use last social-auth instance for current

        # provider, users can associate several accounts with

        # a same provider.

        expiration = social_user.expiration_datetime()

        if expiration:

            try:

                backend.strategy.request.session.set_expiry(

                    expiration.seconds + expiration.days * 86400

                )

            except OverflowError:

                # Handle django time zone overflow

                backend.strategy.request.session.set_expiry(None)

from social.strategies.utils import set_current_strategy_getter

from social.apps.flask_app.utils import load_strategy

set_current_strategy_getter(load_strategy)

"""Flask SQLAlchemy ORM models for Social Auth"""

from sqlalchemy import Column, Integer, String, ForeignKey

from sqlalchemy.orm import relationship, backref

from social.utils import setting_name, module_member

from social.storage.sqlalchemy_orm import SQLAlchemyUserMixin, \

                                          SQLAlchemyAssociationMixin, \

                                          SQLAlchemyNonceMixin, \

                                          SQLAlchemyCodeMixin, \

                                          BaseSQLAlchemyStorage

class FlaskStorage(BaseSQLAlchemyStorage):

    user = None

    nonce = None

    association = None

    code = None

def init_social(app, db):

    UID_LENGTH = app.config.get(setting_name('UID_LENGTH'), 255)

    User = module_member(app.config[setting_name('USER_MODEL')])

    app_session = db.session

    class _AppSession(object):

        @classmethod

        def _session(cls):

            return app_session

    class UserSocialAuth(_AppSession, db.Model, SQLAlchemyUserMixin):

        """Social Auth association model"""

        uid = Column(String(UID_LENGTH))

        user_id = Column(Integer, ForeignKey(User.id),

                         nullable=False, index=True)

        user = relationship(User, backref=backref('social_auth',

                                                  lazy='dynamic'))

        @classmethod

        def username_max_length(cls):

            return User.__table__.columns.get('username').type.length

        @classmethod

        def user_model(cls):

            return User

    class Nonce(_AppSession, db.Model, SQLAlchemyNonceMixin):