fergalmoran/dss.api
1
0
Fork 0
mirror of https://github.com/fergalmoran/dss.api.git synced 2026-01-08 17:44:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Pre feature branch

Browse Source
This commit is contained in:
Fergal Moran
2015-07-12 15:06:49 +01:00
parent deee17c1b1
commit 33e0e58b5e
11 changed files with 194 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
api/auth.py Executable file → Normal file
View File

@@ -1,121 +1 @@
from requests import HTTPError
from rest_framework import parsers
from rest_framework.authentication import get_authorization_header
from rest_framework.authtoken.models import Token
from rest_framework.authtoken.serializers import AuthTokenSerializer
from rest_framework.response import Response
from rest_framework.status import *
from rest_framework.views import APIView
from rest_framework import status
from rest_framework import renderers
from social.apps.django_app.utils import strategy, load_strategy, load_backend
from dss import settings
class LoginException(Exception):
pass
@strategy()
def register_by_access_token(request, backend):
auth = get_authorization_header(request).split()
if not auth or auth[0].lower() != b'social':
raise LoginException("Unable to register_by_access_token: No token header provided")
access_token = auth[1]
return request.backend.do_auth(access_token)
"""
class RefreshTokenView(APIView):
serializer_class = AuthTokenSerializer
model = Token
def post(self, request):
# Here we call PSA to authenticate like we would if we used PSA on server side.
try:
backend = request.META.get('HTTP_AUTH_BACKEND')
if backend is None:
# Work around django test client oddness
return Response("No Auth-Backend header specified", HTTP_400_BAD_REQUEST)
user = refresh_access_token(request, backend)
# If user is active we get or create the REST token and send it back with user data
if user and user.is_active:
token, created = Token.objects.get_or_create(user=user)
return Response({
'slug': user.userprofile.slug,
'token': token.key
})
except LoginException, ex:
return Response(ex.message, HTTP_400_BAD_REQUEST)
except HTTPError, ex:
if ex.response.status_code == 400:
return Response(ex.message, HTTP_401_UNAUTHORIZED)
return Response(ex.message, HTTP_400_BAD_REQUEST)
"""
class ObtainAuthToken(APIView):
serializer_class = AuthTokenSerializer
model = Token
def post(self, request):
# Here we call PSA to authenticate like we would if we used PSA on server side.
try:
backend = request.META.get('HTTP_AUTH_BACKEND')
if backend is None:
# Work around django test client oddness
return Response("No Auth-Backend header specified", HTTP_400_BAD_REQUEST)
user = register_by_access_token(request, backend)
# If user is active we get or create the REST token and send it back with user data
if user and user.is_active:
token, created = Token.objects.get_or_create(user=user)
return Response({
'slug': user.userprofile.slug,
'token': token.key
})
except LoginException, ex:
return Response(ex.message, HTTP_400_BAD_REQUEST)
except HTTPError, ex:
if ex.response.status_code == 400:
return Response(ex.message, HTTP_401_UNAUTHORIZED)
return Response(ex.message, HTTP_400_BAD_REQUEST)
class ObtainUser(APIView):
throttle_classes = ()
permission_classes = ()
parser_classes = (parsers.FormParser, parsers.MultiPartParser, parsers.JSONParser,)
renderer_classes = (renderers.JSONRenderer,)
serializer_class = AuthTokenSerializer
model = Token
def get(self, request):
if request.META.get('HTTP_AUTHORIZATION'):
auth = request.META.get('HTTP_AUTHORIZATION').split()
if not auth or auth[0].lower() != b'token' or len(auth) != 2:
msg = 'Invalid token header. No credentials provided.'
return Response(msg, status=status.HTTP_401_UNAUTHORIZED)
token = Token.objects.get(key=auth[1])
if token and token.user.is_active:
return Response({'id': token.user_id, 'name': token.user.username, 'firstname': token.user.first_name,
'userRole': 'user', 'token': token.key})
else:
return Response(status=status.HTTP_401_UNAUTHORIZED)
class ObtainLogout(APIView):
throttle_classes = ()
permission_classes = ()
parser_classes = (parsers.FormParser, parsers.MultiPartParser, parsers.JSONParser,)
renderer_classes = (renderers.JSONRenderer,)
serializer_class = AuthTokenSerializer
model = Token
# Logout le user
def get(self, request):
return Response({'User': ''})
__author__ = 'fergalm'

24
api/helpers.py
View File

@@ -4,21 +4,35 @@ from rest_framework.status import HTTP_400_BAD_REQUEST, HTTP_201_CREATED, HTTP_2
from rest_framework.views import APIView
from dss import settings
from spa.models import Mix, UserProfile
from core.utils import session
class Helper(APIView):
pass
class ActivityHelper(APIView):
pass
def get_session(self, request):
sessions = session.get_active_sessions(request.session)
return sessions[0]
class ChatHelper(ActivityHelper):
def post(self, request):
# do some persistence stuff with the chat
from core.realtime import chat
user = self.get_session(request)
chat.post_chat(request.DATA['user'], request.DATA['message'])
return Response(request.DATA['message'], HTTP_201_CREATED)
class ActivityPlayHelper(ActivityHelper):
def post(self, request):
if 'id' in self.request.QUERY_PARAMS:
if 'id' in self.request.query_params:
try:
mix = Mix.objects.get(slug=self.request.QUERY_PARAMS.get('id'))
mix = Mix.objects.get(slug=self.request.query_params.get('id'))
mix.add_play(request.user)
data = {
'user': request.user.userprofile.get_nice_name() if request.user.is_authenticated() else settings.DEFAULT_USER_NAME,
@@ -34,7 +48,7 @@ class ActivityPlayHelper(ActivityHelper):
class UserSlugCheckHelper(Helper):
def get(self, request):
try:
UserProfile.objects.get(slug=self.request.QUERY_PARAMS.get('slug'))
UserProfile.objects.get(slug=self.request.query_params.get('slug'))
return Response(status=HTTP_204_NO_CONTENT)
except UserProfile.DoesNotExist:
return Response(status=HTTP_200_OK)

120
api/old_auth.py Executable file
View File

@@ -0,0 +1,120 @@
from requests import HTTPError
from rest_framework import parsers
from rest_framework.authentication import get_authorization_header
from rest_framework.authtoken.models import Token
from rest_framework.authtoken.serializers import AuthTokenSerializer
from rest_framework.response import Response
from rest_framework.status import *
from rest_framework.views import APIView
from rest_framework import status
from rest_framework import renderers
from social.apps.django_app.utils import psa
class LoginException(Exception):
pass
@psa()
def register_by_access_token(request, backend):
auth = get_authorization_header(request).split()
if not auth or auth[0].lower() != b'social':
raise LoginException("Unable to register_by_access_token: No token header provided")
access_token = auth[1]
return request.backend.do_auth(access_token)
"""
class RefreshTokenView(APIView):
serializer_class = AuthTokenSerializer
model = Token
def post(self, request):
# Here we call PSA to authenticate like we would if we used PSA on server side.
try:
backend = request.META.get('HTTP_AUTH_BACKEND')
if backend is None:
# Work around django test client oddness
return Response("No Auth-Backend header specified", HTTP_400_BAD_REQUEST)
user = refresh_access_token(request, backend)
# If user is active we get or create the REST token and send it back with user data
if user and user.is_active:
token, created = Token.objects.get_or_create(user=user)
return Response({
'slug': user.userprofile.slug,
'token': token.key
})
except LoginException, ex:
return Response(ex.message, HTTP_400_BAD_REQUEST)
except HTTPError, ex:
if ex.response.status_code == 400:
return Response(ex.message, HTTP_401_UNAUTHORIZED)
return Response(ex.message, HTTP_400_BAD_REQUEST)
"""
class ObtainAuthToken(APIView):
serializer_class = AuthTokenSerializer
model = Token
def post(self, request):
# Here we call PSA to authenticate like we would if we used PSA on server side.
try:
backend = request.META.get('HTTP_AUTH_BACKEND')
if backend is None:
# Work around django test client oddness
return Response("No Auth-Backend header specified", HTTP_400_BAD_REQUEST)
user = register_by_access_token(request, backend)
# If user is active we get or create the REST token and send it back with user data
if user and user.is_active:
token, created = Token.objects.get_or_create(user=user)
return Response({
'slug': user.userprofile.slug,
'token': token.key
})
except LoginException, ex:
return Response(ex.message, HTTP_400_BAD_REQUEST)
except HTTPError, ex:
if ex.response.status_code == 400:
return Response(ex.message, HTTP_401_UNAUTHORIZED)
return Response(ex.message, HTTP_400_BAD_REQUEST)
class ObtainUser(APIView):
throttle_classes = ()
permission_classes = ()
parser_classes = (parsers.FormParser, parsers.MultiPartParser, parsers.JSONParser,)
renderer_classes = (renderers.JSONRenderer,)
serializer_class = AuthTokenSerializer
model = Token
def get(self, request):
if request.META.get('HTTP_AUTHORIZATION'):
auth = request.META.get('HTTP_AUTHORIZATION').split()
if not auth or auth[0].lower() != b'token' or len(auth) != 2:
msg = 'Invalid token header. No credentials provided.'
return Response(msg, status=status.HTTP_401_UNAUTHORIZED)
token = Token.objects.get(key=auth[1])
if token and token.user.is_active:
return Response({'id': token.user_id, 'name': token.user.username, 'firstname': token.user.first_name,
'userRole': 'user', 'token': token.key})
else:
return Response(status=status.HTTP_401_UNAUTHORIZED)
class ObtainLogout(APIView):
throttle_classes = ()
permission_classes = ()
parser_classes = (parsers.FormParser, parsers.MultiPartParser, parsers.JSONParser,)
renderer_classes = (renderers.JSONRenderer,)
serializer_class = AuthTokenSerializer
model = Token
# Logout le user
def get(self, request):
return Response({'User': ''})

1
api/urls.py
View File

@@ -34,6 +34,7 @@ urlpatterns = patterns(
url(r'^_act/play', helpers.ActivityPlayHelper.as_view()),
url(r'^_chat/', helpers.ChatHelper.as_view()),
url('', include('social.apps.django_app.urls', namespace='social')),
)

14
api/views.py
View File

@@ -75,10 +75,10 @@ class UserProfileViewSet(viewsets.ModelViewSet):
)
def get_queryset(self):
if 'following' in self.request.QUERY_PARAMS:
ret = UserProfile.objects.filter(following__slug__in=[self.request.QUERY_PARAMS['following']])
elif 'followers' in self.request.QUERY_PARAMS:
ret = UserProfile.objects.filter(followers__slug__in=[self.request.QUERY_PARAMS['followers']])
if 'following' in self.request.query_params:
ret = UserProfile.objects.filter(following__slug__in=[self.request.query_params['following']])
elif 'followers' in self.request.query_params:
ret = UserProfile.objects.filter(followers__slug__in=[self.request.query_params['followers']])
else:
ret = super(UserProfileViewSet, self).get_queryset()
@@ -104,7 +104,7 @@ class MixViewSet(viewsets.ModelViewSet):
return Response({'url': mix.get_stream_url()})
def get_queryset(self):
if 'friends' in self.request.QUERY_PARAMS:
if 'friends' in self.request.query_params:
if self.request.user.is_authenticated():
rows = Mix.objects.filter(user__in=self.request.user.userprofile.following.all())
return rows
@@ -242,10 +242,10 @@ class GenreViewSet(viewsets.ModelViewSet):
serializer_class = serializers.GenreSerializer
def get_queryset(self):
if 'q' in self.request.QUERY_PARAMS:
if 'q' in self.request.query_params:
rows = Genre.objects \
.annotate(used=Count('mix')) \
.filter(description__icontains=self.request.QUERY_PARAMS['q']) \
.filter(description__icontains=self.request.query_params['q']) \
.only('description') \
.order_by('-used')
return rows