Skip to content

E
edx-val
Commit e793792a by christopher lee
Options

POST for single EncodedVideo 

POST for EncodedVideo implemented. Can now upload a single Video
with multiple EncodedVideos with profile_name as it's profile.
Cannot do any bulk operations. Serializers have been simplified.
Views are now using genericviews. Queries are now being tracked
in a few tests.

Other notes:
-Added django-debug-toolbar==1.2.1
-constants.py has been reorganized
-api.get_video_info uses new serializer
parent 266fa9f5
Showing with 98 additions and 370 deletions
edxval/api.py
...@@ -5,7 +5,7 @@ The internal API for VAL ...@@ -5,7 +5,7 @@ The internal API for VAL
import logging import logging
from edxval.models import Video from edxval.models import Video
from edxval.serializers import EncodedVideoSetSerializer from edxval.serializers import VideoSerializer
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
...@@ -57,6 +57,7 @@ def get_video_info(edx_video_id, location=None): ...@@ -57,6 +57,7 @@ def get_video_info(edx_video_id, location=None):
Returns all the Video object fields, and it's related EncodedVideo Returns all the Video object fields, and it's related EncodedVideo
objects in a list. objects in a list.
{ {
url: api url to the video
edx_video_id: ID of the video edx_video_id: ID of the video
duration: Length of video in seconds duration: Length of video in seconds
client_video_id: client ID of video client_video_id: client ID of video
...@@ -75,32 +76,27 @@ def get_video_info(edx_video_id, location=None): ...@@ -75,32 +76,27 @@ def get_video_info(edx_video_id, location=None):
ValInternalError: Raised for unknown errors ValInternalError: Raised for unknown errors
Example: Example:
Given one EncodedVideo with edx_video_id "thisis12char-thisis7" Given one EncodedVideo with edx_video_id "example"
>>> >>> get_video_info("example")
>>> get_video_info("thisis12char-thisis7",location)
Returns (dict): Returns (dict):
>>>{ {
>>> 'edx_video_id': u'thisis12char-thisis7', 'url' : '/edxval/video/example'
>>> 'duration': 111.0, 'edx_video_id': u'example',
>>> 'client_video_id': u'Thunder Cats S01E01', 'duration': 111.0,
>>> 'encoded_video': [ 'client_video_id': u'The example video',
>>> { 'encoded_video': [
>>> 'url': u'http://www.meowmix.com', {
>>> 'file_size': 25556, 'url': u'http://www.meowmix.com',
>>> 'bitrate': 9600, 'file_size': 25556,
>>> 'profile': { 'bitrate': 9600,
>>> 'profile_name': u'mobile', 'profile': u'mobile'
>>> 'extension': u'avi', }
>>> 'width': 100, ]
>>> 'height': 101 }
>>> }
>>> },
>>> ]
>>>}
""" """
try: try:
v = Video.objects.get(edx_video_id=edx_video_id) v = Video.objects.get(edx_video_id=edx_video_id)
result = EncodedVideoSetSerializer(v) result = VideoSerializer(v)
except Video.DoesNotExist: except Video.DoesNotExist:
error_message = u"Video not found for edx_video_id: {0}".format(edx_video_id) error_message = u"Video not found for edx_video_id: {0}".format(edx_video_id)
raise ValVideoNotFoundError(error_message) raise ValVideoNotFoundError(error_message)
......
edxval/models.py
...@@ -91,4 +91,4 @@ class EncodedVideo(models.Model): ...@@ -91,4 +91,4 @@ class EncodedVideo(models.Model):
).format(self) ).format(self)
def __unicode__(self): def __unicode__(self):
return repr(self) return repr(self)
\ No newline at end of file
edxval/serializers.py
...@@ -2,101 +2,9 @@ ...@@ -2,101 +2,9 @@
Serializers for Video Abstraction Layer Serializers for Video Abstraction Layer
""" """
from rest_framework import serializers from rest_framework import serializers
from rest_framework.serializers import ValidationError
from edxval.models import Profile, Video, EncodedVideo from edxval.models import Profile, Video, EncodedVideo
class ProfileSerializer2(serializers.ModelSerializer):
class Meta:
model = Profile
fields = (
"profile_name",
"extension",
"width",
"height"
)
class EncodedVideoSerializer2(serializers.ModelSerializer):
profile = serializers.SlugRelatedField(slug_field="profile_name")
class Meta:
model = EncodedVideo
fields = (
"created",
"modified",
"url",
"file_size",
"bitrate",
"profile",
)
class VideoSerializer2(serializers.HyperlinkedModelSerializer):
encoded_videos = EncodedVideoSerializer2(many=True)
class Meta:
model = Video
lookup_field = "edx_video_id"
class DisplayProfileName(serializers.WritableField):
"""
Takes a Profile Object and returns only it's profile_name
"""
def from_native(self, data):
try:
if isinstance(data, int):
profile = Profile.objects.get(pk=data)
elif isinstance(data, unicode):
profile = Profile.objects.get(profile_name=str(data))
return profile
except Profile.DoesNotExist:
error_message = "Profile does not exist: {0}".format(data)
raise ValidationError(error_message)
def to_native(self, data):
return data.profile_name
class DisplayVideoName(serializers.WritableField):
"""
Takes a Video Object and returns only it's profile_name
"""
def from_native(self, data):
#TODO change doc/function name or modify this function, currently
#TODO takes a video pk and converts it to video Object.
try:
if isinstance(data, int):
video = Video.objects.get(pk=data)
return video
except Video.DoesNotExist:
error_message = "Video does not exist: {0}".format(data)
raise ValidationError(error_message)
def to_native(self, data):
return data.edx_video_id
class ListField(serializers.WritableField):
"""
Allows the use of a list as a serializer field.
"""
def from_native(self, data):
if isinstance(data, list):
return data
else:
error_message = "Expecting a list: {0}".format(type(data))
raise ValidationError(error_message)
class Meta:
model = Video
fields = (
"client_video_id",
"duration",
"edx_video_id"
)
class ProfileSerializer(serializers.ModelSerializer): class ProfileSerializer(serializers.ModelSerializer):
class Meta: class Meta:
...@@ -109,175 +17,24 @@ class ProfileSerializer(serializers.ModelSerializer): ...@@ -109,175 +17,24 @@ class ProfileSerializer(serializers.ModelSerializer):
) )
class VideoSerializer(serializers.ModelSerializer):
def restore_object(self, attrs, instance=None):
"""
Given a dictionary of deserialized field values, either update
an existing model instance, or create a new model instance.
"""
if instance is not None:
instance.edx_video_id = attrs.get('edx_video_id', instance.edx_video_id)
instance.duration = attrs.get('duration', instance.duration)
instance.client_video_id = attrs.get('client_video_id', instance.client_video_id)
return instance
return Video(**attrs)
class Meta:
model = Video
fields = (
"client_video_id",
"duration",
"edx_video_id"
)
class EncodedVideoSerializer(serializers.ModelSerializer): class EncodedVideoSerializer(serializers.ModelSerializer):
""" profile = serializers.SlugRelatedField(slug_field="profile_name")
Used to serialize the EncodedVideo for the EncodedVideoSetSerializer
"""
profile = DisplayProfileName()
video = DisplayVideoName()
def restore_object(self, attrs, instance=None):
"""
Given a dictionary of deserialized field values, either update
an existing model instance, or create a new model instance.
"""
if instance is not None:
#TODO Currently not updating Encodedvideo Object.
instance.url = attrs.get('url', instance.url)
instance.file_size = attrs.get('file_size', instance.file_size)
instance.bitrate = attrs.get('bitrate', instance.bitrate)
#TODO profile instance.profile = attrs.get('profile', instance.profile)
return instance
return EncodedVideo(**attrs)
class Meta: class Meta:
model = EncodedVideo model = EncodedVideo
fields = ( fields = (
"created",
"modified",
"url", "url",
"file_size", "file_size",
"bitrate", "bitrate",
"profile", "profile",
"video"
) )
class EncodedVideoSetSerializer(serializers.ModelSerializer): class VideoSerializer(serializers.HyperlinkedModelSerializer):
""" encoded_videos = EncodedVideoSerializer(many=True, allow_add_remove=True)
Used to serialize a list of EncodedVideo objects it's foreign key Video Object.
"""
edx_video_id = serializers.CharField(max_length=50)
encoded_videos = EncodedVideoSerializer(required=False)
class Meta: class Meta:
model = Video model = Video
fields = ( lookup_field = "edx_video_id"
"duration",
"client_video_id",
"edx_video_id",
"encoded_videos"
)
class EncodedVideoSetDeserializer(serializers.Serializer):
"""
Deserializes a dict of Video fields and list of EncodedVideos.
Example:
>>>data = dict(
... client_video_id="Shallow Swordfish",
... duration=122.00,
... edx_video_id="supersoaker",
... encoded_videos=[
... dict(
... url="https://www.swordsingers.com",
... file_size=9000,
... bitrate=42,
... profile=1,
... ),
... dict(
... url="https://www.swordsingers.com",
... file_size=9000,
... bitrate=42,
... profile=2,
... )
... ]
... )
>>>serilizer = EncodedVideoSetDeserializer(data=data)
>>>if serilizer.is_valid()
>>> serializer.save()
>>>video = Video.objects.get(edx_video_id="supersoaker")
>>>print EncodedVideoSetDeserializer(video).data
{
'duration': 122.0,
'client_video_id': u'ShallowSwordfish',
'edx_video_id': u'supersoaker',
'encoded_videos': [
{
'url': u'https: //www.swordsingers.com',
'file_size': 9000,
'bitrate': 42,
'profile': u'mobile',
'video': u'supersoaker'
},
{
'url': u'https: //www.swordsingers.com',
'file_size': 9000,
'bitrate': 42,
'profile': u'desktop',
'video': u'supersoaker'
}
]
}
"""
client_video_id = serializers.CharField(max_length=50)
duration = serializers.FloatField()
edx_video_id = serializers.CharField(max_length=50)
encoded_videos = ListField(required=False)
def restore_object(self, attrs, instance=None):
"""
Updates or creates video object and creates valid EncodedVideo objects.
If the Video parameters are not valid, the errors are returns and the
Video object is not created and the desrialization ends. If any of the
EncodedVideo Parameters are invalid, the errors are returns and the
EncodedVideos objects are not created.
"""
#Get or create the Video object, else return errors
try:
instance = Video.objects.get(edx_video_id=attrs.get("edx_video_id"))
except Video.DoesNotExist:
instance = None
video = VideoSerializer(
data=dict(
edx_video_id=attrs.get("edx_video_id"),
duration=attrs.get("duration"),
client_video_id=attrs.get("client_video_id")
),
instance=instance
)
if video.is_valid():
video.save()
else:
for key in video.errors:
self.errors[key] = video.errors[key]
return
#Point encoded_videos to parent video
if not "encoded_videos" in attrs:
return video
for item in attrs.get("encoded_videos"):
item[u"video"] = Video.objects.get(edx_video_id=attrs.get("edx_video_id")).pk
#Serialize EncodedVideos, else raise errors
ev = EncodedVideoSerializer(data=attrs.get("encoded_videos"), many=True)
if ev.is_valid():
ev.save()
else:
self.errors["encoded_videos"] = ev.errors
return video
\ No newline at end of file
edxval/tests/constants.py
...@@ -36,6 +36,7 @@ VIDEO_DICT_NEGATIVE_DURATION = dict( ...@@ -36,6 +36,7 @@ VIDEO_DICT_NEGATIVE_DURATION = dict(
client_video_id="Thunder Cats S01E01", client_video_id="Thunder Cats S01E01",
duration=-111, duration=-111,
edx_video_id="thisis12char-thisis7", edx_video_id="thisis12char-thisis7",
encoded_videos=[]
) )
ENCODED_VIDEO_DICT_NEGATIVE_FILESIZE = dict( ENCODED_VIDEO_DICT_NEGATIVE_FILESIZE = dict(
url="http://www.meowmix.com", url="http://www.meowmix.com",
...@@ -47,18 +48,32 @@ ENCODED_VIDEO_DICT_NEGATIVE_BITRATE = dict( ...@@ -47,18 +48,32 @@ ENCODED_VIDEO_DICT_NEGATIVE_BITRATE = dict(
file_size=25556, file_size=25556,
bitrate=-9600, bitrate=-9600,
) )
VIDEO_DICT_BEE_INVALID = dict(
client_video_id="Barking Bee",
duration=111.00,
edx_video_id="wa/sps",
)
VIDEO_DICT_INVALID_ID = dict(
client_video_id="SuperSloth",
duration=42,
edx_video_id="sloppy/sloth!!",
encoded_videos=[]
)
""" """
Non-latin Non-latin/invalid
""" """
VIDEO_DICT_NON_LATIN_TITLE = dict( VIDEO_DICT_NON_LATIN_TITLE = dict(
client_video_id="배고픈 햄스터", client_video_id=u"배고픈 햄스터",
duration=42, duration=42,
edx_video_id="ID" edx_video_id="ID",
encoded_videos=[]
) )
VIDEO_DICT_NON_LATIN_ID = dict( VIDEO_DICT_NON_LATIN_ID = dict(
client_video_id="Hungry Hamster", client_video_id="Hungry Hamster",
duration=42, duration=42,
edx_video_id="밥줘" edx_video_id="밥줘",
encoded_videos=[]
) )
PROFILE_DICT_NON_LATIN = dict( PROFILE_DICT_NON_LATIN = dict(
profile_name=u"배고파", profile_name=u"배고파",
...@@ -140,19 +155,12 @@ ENCODED_VIDEO_DICT_STAR = dict( ...@@ -140,19 +155,12 @@ ENCODED_VIDEO_DICT_STAR = dict(
url="https://www.howIwonder.com", url="https://www.howIwonder.com",
file_size=9000, file_size=9000,
bitrate=42, bitrate=42,
profile=1 profile="mobile"
)
ENCODED_VIDEO_DICT_STAR2 = dict(
url="https://www.whatyouare.com",
file_size=1111,
bitrate=2333,
profile=2
) )
COMPLETE_SET_STAR = dict( COMPLETE_SET_STAR = dict(
encoded_videos=[ encoded_videos=[
ENCODED_VIDEO_DICT_STAR, ENCODED_VIDEO_DICT_STAR
ENCODED_VIDEO_DICT_STAR2
], ],
**VIDEO_DICT_STAR **VIDEO_DICT_STAR
) )
...@@ -173,8 +181,8 @@ COMPLETE_SET_EXTRA_VIDEO_FIELD = dict( ...@@ -173,8 +181,8 @@ COMPLETE_SET_EXTRA_VIDEO_FIELD = dict(
url="https://www.vulturevideos.com", url="https://www.vulturevideos.com",
file_size=101010, file_size=101010,
bitrate=1234, bitrate=1234,
profile=1, profile="mobile",
video="This should be overridden by parent videofield" video="This should be overridden by parent video field"
) )
], ],
**VIDEO_DICT_STAR **VIDEO_DICT_STAR
...@@ -185,14 +193,21 @@ Unsorted ...@@ -185,14 +193,21 @@ Unsorted
VIDEO_DICT_COAT = dict( VIDEO_DICT_COAT = dict(
client_video_id="Callous Coat", client_video_id="Callous Coat",
duration=111.00, duration=111.00,
edx_video_id="itchyjacket", edx_video_id="itchyjacket"
) )
VIDEO_DICT_AVERAGE = dict( VIDEO_DICT_ANIMAL = dict(
client_video_id="Average Animal", client_video_id="Average Animal",
duration=111.00, duration=111.00,
edx_video_id="mediocrity", edx_video_id="mediocrity",
encoded_videos=[]
)
VIDEO_DICT_ZEBRA = dict(
client_video_id="Zesty Zebra",
duration=111.00,
edx_video_id="zestttt",
encoded_videos=[]
) )
VIDEO_DICT_AVERAGE2 = dict( VIDEO_DICT_UPDATE_ANIMAL = dict(
client_video_id="Lolcat", client_video_id="Lolcat",
duration=122.00, duration=122.00,
edx_video_id="mediocrity", edx_video_id="mediocrity",
...@@ -204,18 +219,6 @@ VIDEO_DICT_CRAYFISH = dict( ...@@ -204,18 +219,6 @@ VIDEO_DICT_CRAYFISH = dict(
edx_video_id="craycray", edx_video_id="craycray",
) )
VIDEO_DICT_BEE_INVALID = dict(
client_video_id="Barking Bee",
duration=111.00,
edx_video_id="wa/sps",
)
VIDEO_DICT_INVALID_ID = dict(
client_video_id="SuperSloth",
duration=42,
edx_video_id="sloppy/sloth!!"
)
VIDEO_DICT_DUPLICATES = [ VIDEO_DICT_DUPLICATES = [
VIDEO_DICT_CRAYFISH, VIDEO_DICT_CRAYFISH,
VIDEO_DICT_CRAYFISH, VIDEO_DICT_CRAYFISH,
...@@ -234,7 +237,7 @@ COMPLETE_SETS_ONE_INVALID = [ ...@@ -234,7 +237,7 @@ COMPLETE_SETS_ONE_INVALID = [
VIDEO_DICT_SET_OF_THREE = [ VIDEO_DICT_SET_OF_THREE = [
VIDEO_DICT_COAT, VIDEO_DICT_COAT,
VIDEO_DICT_AVERAGE, VIDEO_DICT_ANIMAL,
VIDEO_DICT_CRAYFISH VIDEO_DICT_CRAYFISH
] ]
......
edxval/tests/test_api.py
...@@ -10,7 +10,7 @@ from django.db import DatabaseError ...@@ -10,7 +10,7 @@ from django.db import DatabaseError
from edxval.models import Profile, Video, EncodedVideo from edxval.models import Profile, Video, EncodedVideo
from edxval import api as api from edxval import api as api
from edxval.serializers import EncodedVideoSetSerializer from edxval.serializers import VideoSerializer
from edxval.tests import constants from edxval.tests import constants
...@@ -51,8 +51,11 @@ class GetVideoInfoTest(TestCase): ...@@ -51,8 +51,11 @@ class GetVideoInfoTest(TestCase):
""" """
Tests searching for a video that does not exist Tests searching for a video that does not exist
""" """
with self.assertRaises(api.ValVideoNotFoundError):
api.get_video_info("non_existant-video__")
with self.assertRaises(api.ValVideoNotFoundError): with self.assertRaises(api.ValVideoNotFoundError):
api.get_video_info("non_existing-video__") api.get_video_info("")
def test_unicode_input(self): def test_unicode_input(self):
""" """
...@@ -61,7 +64,7 @@ class GetVideoInfoTest(TestCase): ...@@ -61,7 +64,7 @@ class GetVideoInfoTest(TestCase):
with self.assertRaises(api.ValVideoNotFoundError): with self.assertRaises(api.ValVideoNotFoundError):
api.get_video_info(u"๓ﻉѻฝ๓ٱซ") api.get_video_info(u"๓ﻉѻฝ๓ٱซ")
@mock.patch.object(EncodedVideoSetSerializer, '__init__') @mock.patch.object(VideoSerializer, '__init__')
def test_force_internal_error(self, mock_init): def test_force_internal_error(self, mock_init):
""" """
Tests to see if an unknown error will be handled Tests to see if an unknown error will be handled
......
edxval/tests/test_serializers.py
...@@ -7,11 +7,8 @@ from django.test import TestCase ...@@ -7,11 +7,8 @@ from django.test import TestCase
from edxval.serializers import ( from edxval.serializers import (
EncodedVideoSerializer, EncodedVideoSerializer,
EncodedVideoSetSerializer,
ProfileSerializer, ProfileSerializer,
VideoSerializer, VideoSerializer,
DisplayProfileName
) )
from edxval.models import Profile, Video, EncodedVideo from edxval.models import Profile, Video, EncodedVideo
from edxval.tests import constants from edxval.tests import constants
...@@ -23,15 +20,15 @@ class SerializerTests(TestCase): ...@@ -23,15 +20,15 @@ class SerializerTests(TestCase):
""" """
def setUp(self): def setUp(self):
""" """
Creates EncodedVideo objects in database Creates Profile objects
""" """
Profile.objects.create(**constants.PROFILE_DICT_MOBILE) Profile.objects.create(**constants.PROFILE_DICT_MOBILE)
Profile.objects.create(**constants.PROFILE_DICT_DESKTOP) Profile.objects.create(**constants.PROFILE_DICT_DESKTOP)
Profile.objects.create(**constants.PROFILE_DICT_NON_LATIN) Profile.objects.create(**constants.PROFILE_DICT_NON_LATIN)
def test_negative_fields_only_encoded_video(self): def test_negative_fields_for_encoded_video_serializer(self):
""" """
Tests negative inputs for OnlyEncodedSerializer Tests negative inputs for EncodedVideoSerializer
Tests negative inputs for bitrate, file_size in EncodedVideo Tests negative inputs for bitrate, file_size in EncodedVideo
""" """
...@@ -45,26 +42,34 @@ class SerializerTests(TestCase): ...@@ -45,26 +42,34 @@ class SerializerTests(TestCase):
self.assertEqual(b.get('file_size')[0], self.assertEqual(b.get('file_size')[0],
u"Ensure this value is greater than or equal to 0.") u"Ensure this value is greater than or equal to 0.")
def test_negative_fields_video_set(self): def test_negative_fields_for_video_serializer(self):
""" """
Tests negative inputs for EncodedVideoSetSerializer Tests negative inputs for VideoSerializer
Tests negative inputs for duration in model Video Tests negative inputs for duration in model Video
""" """
c = EncodedVideoSetSerializer( c = VideoSerializer(
data=constants.VIDEO_DICT_NEGATIVE_DURATION).errors data=constants.VIDEO_DICT_NEGATIVE_DURATION).errors
self.assertEqual(c.get('duration')[0], self.assertEqual(c.get('duration')[0],
u"Ensure this value is greater than or equal to 0.") u"Ensure this value is greater than or equal to 0.")
def test_unicode_inputs(self): def test_non_latin_serialization(self):
""" """
Tests if the serializers can accept non-latin chars Tests if the serializers can accept non-latin chars
""" """
#TODO not the best test. Need to understand what result we want #TODO not the best test. Need to understand what result we want
self.assertIsNotNone( self.assertIsInstance(
ProfileSerializer(Profile.objects.get(profile_name="배고파")) ProfileSerializer(Profile.objects.get(profile_name="배고파")),
ProfileSerializer
) )
def test_non_latin_deserialization(self):
"""
Tests deserialization of non-latin data
"""
#TODO write a test for this when we understand what we want
pass
def test_invalid_edx_video_id(self): def test_invalid_edx_video_id(self):
""" """
Test the Video model regex validation for edx_video_id field Test the Video model regex validation for edx_video_id field
...@@ -84,11 +89,14 @@ class SerializerTests(TestCase): ...@@ -84,11 +89,14 @@ class SerializerTests(TestCase):
video=video, video=video,
profile=Profile.objects.get(profile_name="desktop"), profile=Profile.objects.get(profile_name="desktop"),
**constants.ENCODED_VIDEO_DICT_DESKTOP **constants.ENCODED_VIDEO_DICT_DESKTOP
) )
EncodedVideo.objects.create( EncodedVideo.objects.create(
video=video, video=video,
profile=Profile.objects.get(profile_name="mobile"), profile=Profile.objects.get(profile_name="mobile"),
**constants.ENCODED_VIDEO_DICT_MOBILE **constants.ENCODED_VIDEO_DICT_MOBILE
) )
result = EncodedVideoSetSerializer(video).data result = VideoSerializer(video).data
# Check for 2 EncodedVideo entries
self.assertEqual(len(result.get("encoded_videos")), 2) self.assertEqual(len(result.get("encoded_videos")), 2)
# Check for original Video data
self.assertDictContainsSubset(constants.VIDEO_DICT_COAT, result)
edxval/urls.py
...@@ -14,5 +14,3 @@ urlpatterns = patterns('', ...@@ -14,5 +14,3 @@ urlpatterns = patterns('',
name="video-detail"), name="video-detail"),
url(r'^admin/', include(admin.site.urls)), url(r'^admin/', include(admin.site.urls)),
) )
urlpatterns = format_suffix_patterns(urlpatterns)
\ No newline at end of file
edxval/views.py
from rest_framework.views import APIView from rest_framework import generics
from rest_framework.response import Response
from rest_framework import status, generics
from edxval.models import Video from edxval.models import Video
from edxval.serializers import ( from edxval.serializers import (
VideoSerializer, EncodedVideoSetDeserializer, EncodedVideoSetSerializer, VideoSerializer
VideoSerializer2,
) )
# class VideoList(APIView):
# """
# <<<<<<< HEAD
# HTTP API for Video and EncodedVideo objects
# """
#
# def get(self, request, format=None):
# """
# Gets all videos
# """
# video = Video.objects.all()
# serializer = EncodedVideoSetSerializer(video, many=True)
# return Response(serializer.data)
#
# def post(self, request, format=None):
# """
# Takes a Video dict of a list of EncodedVideo dicts and creates the objects
#
# Args:
# request (object): Object where we get our information for POST
# data_format (str): format of our data (JSON, XML, etc.)
#
# Returns:
# Response(message, HTTP status)
#
# """
# serializer = EncodedVideoSetDeserializer(data=request.DATA)
# if serializer.is_valid():
# serializer.save()
# return Response("Success", status=status.HTTP_201_CREATED)
# else:
# return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class VideoList(generics.ListCreateAPIView): class VideoList(generics.ListCreateAPIView):
queryset = Video.objects.all().select_related("encoded_videos") """
GETs or POST video objects
"""
queryset = Video.objects.all().prefetch_related("encoded_videos")
lookup_field = "edx_video_id" lookup_field = "edx_video_id"
serializer_class = VideoSerializer2 serializer_class = VideoSerializer
class VideoDetail(generics.RetrieveUpdateDestroyAPIView): class VideoDetail(generics.RetrieveUpdateDestroyAPIView):
""" """
...@@ -53,4 +21,4 @@ class VideoDetail(generics.RetrieveUpdateDestroyAPIView): ...@@ -53,4 +21,4 @@ class VideoDetail(generics.RetrieveUpdateDestroyAPIView):
""" """
lookup_field = "edx_video_id" lookup_field = "edx_video_id"
queryset = Video.objects.all() queryset = Video.objects.all()
serializer_class = VideoSerializer2 serializer_class = VideoSerializer
urls.py
...@@ -14,5 +14,3 @@ urlpatterns = patterns('', ...@@ -14,5 +14,3 @@ urlpatterns = patterns('',
name="video_detail_view"), name="video_detail_view"),
url(r'^admin/', include(admin.site.urls)), url(r'^admin/', include(admin.site.urls)),
) )
urlpatterns = format_suffix_patterns(urlpatterns)
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment