Connect functionality for social account linking

Hi,

I recently wrote some account connection logic into our application with django-allauth and django-rest-auth for use with a mobile application and REST API.

I found out that it would be fairly easy to bundle connect and disconnect views in the application.

Should these serializers and views be included in the django-rest-auth package?

from allauth.socialaccount.adapter import get_adapter
from allauth.socialaccount.models import SocialAccount
from allauth.socialaccount.providers.facebook.views import FacebookOAuth2Adapter

from rest_auth.registration.serializers import SocialLoginSerializer

from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response

### 
# Social account connect functionality for django-rest-auth

class SocialConnectSerializer(SocialLoginSerializer):
     """Specialize social login process state to `connect`"""

    def get_social_login(self, *args, **kwargs):
        social_login = super().get_social_login(*args, **kwargs)
        social_login.state['process'] = 'connect'
        return social_login


class SocialConnectMixin(SocialLoginView):
    """Connect view for logged in users

    The django-allauth module internally uses a request attribute
    called 'process' to set the required action, we override that
    in the SocialConnectSerializer for use with the REST API.
    """

    serializer_class = SocialConnectSerializer
    permission_classes = (IsAuthenticated, )

###
# Usage example of login and connect functionality for Facebook

class FacebookConfigurationMixin(object):
    adapter_class = FacebookOAuth2Adapter


class FacebookLogin(FacebookConfigurationMixin, SocialLoginView):
    """Login user with given Facebook account"""
    pass

class FacebookConnect(FacebookConfigurationMixin, SocialConnectMixin, SocialLoginView):
    """Connect given Facebook account for logged in user"""
    pass


###
# SocialAccount viewing and disconnection

class SocialAccountSerializer(serializers.ModelSerializer):
    class Meta:
        model = SocialAccount
        fields = (
            'id',
            'provider',
            'uid',
            'last_login',
            'date_joined',
            'extra_data',
        )


class SocialAccountViewSet(GenericViewSet):
    """SocialAccount views for logged in users"""

    permission_classes = (IsAuthenticated, )
    serializer_class = SocialAccountSerializer
    queryset = SocialAccount.objects.none()

    def get_queryset(self):
        return SocialAccount.objects.filter(user=self.request.user)

    def list(self, request):
        """List SocialAccounts for currently logged in user"""

        return Response(self.get_serializer(self.get_queryset(), many=True).data)

    @detail_route(methods=['POST'])
    def disconnect(self, request, pk):
        """Disconnect SocialAccount from remote service

        This is the same logic as used in the web UI form,
        refer to the allauth implementation for more details.
        """

        accounts = self.get_queryset()
        account = accounts.get(pk=pk)
        get_adapter(self.request).validate_disconnect(account, accounts)

        account.delete()
        signals.social_account_removed.send(
            sender=SocialAccount,
            request=self.request,
            socialaccount=account
        )

        return Response(self.get_serializer(account).data)

[aleksihakli]

I hoped the authors would comment on this but I will try and open a PR for this today 😃

[Moulde]

Can anyone point me in the direction of a sample that shows how to use the above? I’m a bit confused about how I use the allauth providers, like github, with the django-rest-auth library.